LibAcc: 0.7917=57/72, ProjAcc: 1.0000=0/0, Missing: 350

Module: packages/junctions/examples/Blog

function 𝓟1{ArticleComponent} (𝓟2{props}: 𝓛[ty]8642{Object}): (𝓟3: [OOV]any)
{
 let 𝓟4{page}: [OOV]𝓟[ty]2597{Page} = 𝓟2{props}.page;
 return 𝓟3 = 𝓛12563{undefined}
}
let 𝓟5{Landing}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟339{createPageTemplate}({title: 𝓛8743{String},component: 𝓟1{ArticleComponent}});
let 𝓟6{Latest}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟339{createPageTemplate}({title: 𝓛8743{String},component: 𝓟1{ArticleComponent}});
let 𝓟7{Article1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟339{createPageTemplate}({title: 𝓛8743{String},component: 𝓟1{ArticleComponent}});
let 𝓟8{Article2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟339{createPageTemplate}({title: 𝓛8743{String},component: 𝓟1{ArticleComponent}});
function 𝓟9{$Lambda0} (𝓟10{_}): (𝓟11: [miss]𝓛[ty]8642{Object})
{
}
let 𝓟12{ArticlesJunction}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟138{createJunctionTemplate}(𝓟9{$Lambda0});
function 𝓟13{$Lambda1} (𝓟14{_}): (𝓟15: [miss]𝓛[ty]8642{Object})
{
}
let 𝓟16{AppJunction}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟138{createJunctionTemplate}(𝓟13{$Lambda1});

Module: packages/junctions/src/Patterns

type 𝓟[ty]2569{MountedPattern} extends 𝓟[ty]2568{CompiledPattern} = {params: 𝓛[ty]8670{Array}, relativeSearchParams: 𝓛[ty]8670{Array}}
type 𝓟[ty]2563{PatternMatch} = {params: {access: (𝓛[ty]10051{String})->any}, matchedLocation: 𝓟[ty]2586{Location}, remainingLocation: 𝓟[ty]2586{Location}}
type 𝓟[ty]2568{CompiledPattern} = {relativePathParams: 𝓛[ty]8670{Array}, relativePattern: 𝓛[ty]10051{String}, relativeRegExp: 𝓛[ty]8662{RegExp}, template: any, relativeKey: 𝓛[ty]10051{String}}
const 𝓟20{KEY_WILDCARD}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟21{KEY_WILDCARD_PATTERN}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp};
function 𝓟22{createRootMountedPattern} (𝓟23{template}: [OOV]𝓛[ty]0{ANY},𝓟24{relativePath}: 𝓛[ty]10051{String}): (𝓟25: [OOV]𝓟[ty]2569{MountedPattern})
{
 let 𝓟26{rootPattern}: [OOV]𝓟[ty]2568{CompiledPattern} = (𝓟24{relativePath} ? 𝓟27{compilePattern}(𝓟24{relativePath},𝓟23{template}) : {relativePattern: 𝓟24{relativePath}.BarBarToken(𝓛8743{String}),relativeKey: 𝓛8743{String},relativeRegExp: 𝓛8748{RegExp}.CONSTRUCTOR(𝓛8743{String}),template: 𝓟23{template}};
 if (𝓟26{rootPattern}.relativePathParams.AmpersandAmpersandToken(𝓟26{rootPattern}.relativePathParams.length.GreaterThanToken(𝓛8745{Number})))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 return 𝓟25 = {params: 𝓛8757{Array}()}
}
function 𝓟27{compilePattern} (𝓟28{pattern}: 𝓛[ty]10051{String},𝓟29{template}: [OOV]any): (𝓟30: [OOV]𝓟[ty]2568{CompiledPattern})
{
 let 𝓟31{processedPattern}: [miss]𝓛[ty]10051{String} = 𝓟28{pattern};
 if (𝓟31{processedPattern}.length.GreaterThanToken(𝓛8745{Number}).AmpersandAmpersandToken(𝓟31{processedPattern}.substr(𝓛12557{MinusToken}(𝓛8745{Number})).EqualsEqualsEqualsToken(𝓛8743{String})))
 {
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟28{pattern}))
 }
 𝓟31{processedPattern} ⟵ 𝓟31{processedPattern}.substr(𝓛8745{Number},𝓟31{processedPattern}.length.MinusToken(𝓛8745{Number}));
 }
 if (𝓟31{processedPattern}.access(𝓛8745{Number}).ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟28{pattern}))
 }
 𝓟31{processedPattern} ⟵ 𝓛8743{String}.PlusToken(𝓟31{processedPattern});
 }
 if (𝓛8748{RegExp}.test(𝓟31{processedPattern}))
 {
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟28{pattern}))
 }
 𝓟31{processedPattern} ⟵ 𝓟31{processedPattern}.replace(𝓛8748{RegExp},𝓛8743{String});
 }
 if (𝓛12548{ExclamationToken}(𝓛8748{RegExp}.test(𝓟31{processedPattern})))
 {
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟28{pattern}))
 }
 }
 if (𝓟31{processedPattern}.length.EqualsEqualsEqualsToken(𝓛8745{Number}))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 let 𝓟32{parts}: [miss]𝓛[ty]8670{Array} = 𝓟31{processedPattern}.split(𝓛8743{String}).slice(𝓛8745{Number});
 let 𝓟33{pathParams}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
 let 𝓟34{keyParts}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
 let 𝓟35{regExpParts}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8743{String});
 {
 let 𝓟36{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓟36{i}.FirstBinaryOperator(𝓟32{parts}.length))
 {
 {
 let 𝓟37{part}: [miss]𝓛[ty]10051{String} = 𝓟32{parts}.access(𝓟36{i});
 if (𝓟37{part}.length.GreaterThanToken(𝓛8745{Number}).AmpersandAmpersandToken(𝓟37{part}.access(𝓛8745{Number}).EqualsEqualsEqualsToken(𝓛8743{String})))
 {
 𝓟33{pathParams}.push(𝓟37{part}.slice(𝓛8745{Number}))
 𝓟34{keyParts}.push(𝓟20{KEY_WILDCARD})
 𝓟35{regExpParts}.push(𝓛8743{String})
 }
 else
 {
 𝓟34{keyParts}.push(𝓟37{part})
 𝓟35{regExpParts}.push(𝓟78{escapeRegExp}(𝓟37{part}))
 }
 }
 𝓛12546{POST_PlusPlusToken}(𝓟36{i})
 }
 }
 return 𝓟30 = {relativePathParams: (𝓟33{pathParams}.length ? 𝓟33{pathParams} : 𝓛12563{undefined},relativePattern: 𝓟31{processedPattern},relativeRegExp: 𝓛8748{RegExp}.CONSTRUCTOR(𝓟35{regExpParts}.join(𝓛8743{String})),template: 𝓟29{template},relativeKey: 𝓟34{keyParts}.join(𝓛8743{String})}
}
function 𝓟38{createChildMountedPattern} (𝓟39{parentPattern}: [OOV]𝓟[ty]2569{MountedPattern},𝓟40{compiledPattern}: [OOV]𝓟[ty]2568{CompiledPattern}): (𝓟41: [OOV]𝓟[ty]2569{MountedPattern})
{
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 if (𝓟40{compiledPattern}.relativePathParams)
 {
 function 𝓟42{$Lambda26} (𝓟43{param}): (𝓟44: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟44 = 𝓟39{parentPattern}.params.indexOf(𝓟43{param}).ExclamationEqualsEqualsToken(𝓛12557{MinusToken}(𝓛8745{Number}))
 }
 let 𝓟45{doubleParams}: [miss]𝓛[ty]8670{Array} = 𝓟40{compiledPattern}.relativePathParams.filter(𝓟42{$Lambda26});
 if (𝓟45{doubleParams}.length)
 {
 function 𝓟46{$Lambda27} (𝓟47{x}): (𝓟48: [miss]𝓛[ty]10051{String})
 {
 return 𝓟48 = 𝓛12554{$Template}(𝓟47{x})
 }
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟40{compiledPattern}.relativePattern,𝓟45{doubleParams}.map(𝓟46{$Lambda27}).join(𝓛8743{String})))
 }
 }
 }
 return 𝓟41 = {params: 𝓟39{parentPattern}.params.concat(𝓟40{compiledPattern}.relativePathParams.BarBarToken(𝓛8757{Array}()))}
}
function 𝓟49{addParamsToMountedPattern} (𝓟50{pattern}: [OOV]𝓟[ty]2569{MountedPattern},𝓟51{params}: 𝓛[ty]8670{Array}): (𝓟52: [OOV]𝓟[ty]2569{MountedPattern})
{
 let 𝓟53{relativeSearchParams}: [miss]𝓛[ty]8670{Array} = 𝓟51{params}.BarBarToken(𝓛8757{Array}());
 if (𝓟50{pattern}.relativePathParams)
 {
 {
 let 𝓟54{i}: [miss]𝓛[ty]8655{Number} = 𝓟50{pattern}.relativePathParams.length.MinusToken(𝓛8745{Number});
 while (𝓟54{i}.GreaterThanEqualsToken(𝓛8745{Number}))
 {
 {
 let 𝓟55{pathParam}: [miss]𝓛[ty]10051{String} = 𝓟50{pattern}.relativePathParams.access(𝓟54{i});
 let 𝓟56{index}: [miss]𝓛[ty]8655{Number} = 𝓟53{relativeSearchParams}.indexOf(𝓟55{pathParam});
 if (𝓟56{index}.EqualsEqualsEqualsToken(𝓛12557{MinusToken}(𝓛8745{Number})))
 {
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟55{pathParam}))
 }
 }
 else
 {
 𝓟53{relativeSearchParams}.splice(𝓟56{index},𝓛8745{Number})
 }
 }
 𝓛12555{POST_MinusMinusToken}(𝓟54{i})
 }
 }
 }
 if (𝓟53{relativeSearchParams}.length.EqualsEqualsEqualsToken(𝓛8745{Number}))
 {
 return 𝓟52 = 𝓟50{pattern}
 }
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 function 𝓟57{$Lambda28} (𝓟58{param}): (𝓟59: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟59 = 𝓟50{pattern}.params.indexOf(𝓟58{param}).ExclamationEqualsEqualsToken(𝓛12557{MinusToken}(𝓛8745{Number}))
 }
 let 𝓟60{doubleParams}: [miss]𝓛[ty]8670{Array} = 𝓟53{relativeSearchParams}.filter(𝓟57{$Lambda28});
 if (𝓟60{doubleParams}.length)
 {
 function 𝓟61{$Lambda29} (𝓟62{x}): (𝓟63: [miss]𝓛[ty]10051{String})
 {
 return 𝓟63 = 𝓛12554{$Template}(𝓟62{x})
 }
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟50{pattern}.relativePattern,𝓟60{doubleParams}.map(𝓟61{$Lambda29}).join(𝓛8743{String})))
 }
 }
 return 𝓟52 = {relativeSearchParams: (𝓟53{relativeSearchParams}.length ? 𝓟53{relativeSearchParams} : 𝓛12563{undefined}}
}
function 𝓟64{matchMountedPatternAgainstLocation} (𝓟65{pattern}: [OOV]𝓟[ty]2569{MountedPattern},𝓟66{location}: [OOV]𝓟[ty]2586{Location}): (𝓟67: [OOV]any)
{
 let 𝓟68{match}: [OOV]𝓛[ty]8682{RegExpExecArray} = 𝓟65{pattern}.relativeRegExp.exec(𝓟66{location}.pathname);
 let 𝓟69{params}: [miss]𝓛[ty]8642{Object} = {};
 if (𝓛12548{ExclamationToken}(𝓟68{match}))
 {
 }
 if (𝓟65{pattern}.relativePathParams)
 {
 {
 let 𝓟70{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓟70{i}.FirstBinaryOperator(𝓟65{pattern}.relativePathParams.length))
 {
 {
 let 𝓟71{paramName}: [miss]𝓛[ty]10051{String} = 𝓟65{pattern}.relativePathParams.access(𝓟70{i});
 𝓟69{params}.access(𝓟71{paramName}) ⟵ 𝓟68{match}.access(𝓟70{i}.PlusToken(𝓛8745{Number}));
 }
 𝓛12546{POST_PlusPlusToken}(𝓟70{i})
 }
 }
 }
 let 𝓟72{matchedQueryParts}: [miss]𝓛[ty]8642{Object} = {};
 let 𝓟73{remainingQueryParts}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟753{parseQuery}(𝓟66{location}.search);
 if (𝓟65{pattern}.relativeSearchParams)
 {
 {
 let 𝓟74{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓟74{i}.FirstBinaryOperator(𝓟65{pattern}.relativeSearchParams.length))
 {
 {
 let 𝓟75{paramName}: [miss]𝓛[ty]10051{String} = 𝓟65{pattern}.relativeSearchParams.access(𝓟74{i});
 if (𝓟73{remainingQueryParts}.access(𝓟75{paramName}).ExclamationEqualsEqualsToken(𝓛12563{undefined}))
 {
 𝓟69{params}.access(𝓟75{paramName}) ⟵ 𝓟73{remainingQueryParts}.access(𝓟75{paramName});
 𝓟72{matchedQueryParts}.access(𝓟75{paramName}) ⟵ 𝓟73{remainingQueryParts}.access(𝓟75{paramName});
 𝓛12560{$Delete}(𝓟73{remainingQueryParts}.access(𝓟75{paramName}))
 }
 }
 𝓛12546{POST_PlusPlusToken}(𝓟74{i})
 }
 }
 }
 let 𝓟76{matchedLocation}: [miss]𝓛[ty]8642{Object} = {pathname: 𝓟68{match}.access(𝓛8745{Number}),search: 𝓟762{stringifyQuery}(𝓟72{matchedQueryParts})};
 let 𝓟77{remainingLocation}: [miss]𝓛[ty]8642{Object} = {pathname: 𝓟66{location}.pathname.slice(𝓟68{match}.access(𝓛8745{Number}).length),search: 𝓟762{stringifyQuery}(𝓟73{remainingQueryParts}),hash: 𝓟66{location}.hash,state: 𝓟66{location}.state};
 return 𝓟67 = {params: 𝓟69{params},matchedLocation: 𝓟76{matchedLocation},remainingLocation: (𝓟77{remainingLocation}.pathname.ExclamationEqualsEqualsToken(𝓛8743{String}).BarBarToken(𝓟77{remainingLocation}.search.ExclamationEqualsEqualsToken(𝓛8743{String})) ? 𝓟77{remainingLocation} : 𝓛12563{undefined}}
}
function 𝓟78{escapeRegExp} (𝓟79{value}): (𝓟80: [OOV]any)
{
 return 𝓟80 = 𝓟79{value}.replace(𝓛8748{RegExp},𝓛8743{String})
}

Module: packages/junctions/src/RouterConfig

type 𝓟[ty]2574{RouterConfig} = {rootJunctionTemplate: any, rootMountedPattern: 𝓟[ty]2569{MountedPattern}, onEvent: (𝓟[ty]2614{RouterEvent})->𝓛[ty]10033{Void}}
type 𝓟[ty]2614{RouterEvent} = {type: any, location: 𝓟[ty]2586{Location}}
function 𝓟83{createRouterConfig} (𝓟84{options}: 𝓛[ty]8642{Object}): (𝓟85: [OOV]𝓟[ty]2574{RouterConfig})
{
 function 𝓟86{$Lambda32} (): (𝓟87: [miss]𝓛[ty]10033{Void})
 {
 }
 return 𝓟85 = {rootJunctionTemplate: 𝓟84{options}.rootJunctionTemplate,rootMountedPattern: 𝓟22{createRootMountedPattern}(𝓟84{options}.rootJunctionTemplate,𝓟84{options}.rootPath),onEvent: 𝓟84{options}.onEvent.BarBarToken(𝓟86{$Lambda32})}
}

Module: packages/junctions/src/Deferred

function 𝓟88{CONSTRUCTOR} (): (𝓟[ty]96{Deferred})
{
 const 𝓟[ty]96{Deferred};
 const 𝓟[ty]96{Deferred};
 function 𝓟92{$Lambda16} (𝓟93{resolve},𝓟94{reject}): (𝓟95: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]96{Deferred}.resolve ⟵ 𝓟93{resolve};
 𝓟[ty]96{Deferred}.reject ⟵ 𝓟94{reject};
 }
 𝓟[ty]96{Deferred}.promise ⟵ 𝓛1062{Promise}.CONSTRUCTOR(𝓟92{$Lambda16}.bind(𝓟[ty]96{Deferred}));
 𝓛8741{Object}.freeze(𝓟[ty]96{Deferred})
}
class 𝓟[ty]96{Deferred}{
 𝓟98{promise}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8654{Promise});
 𝓟99{resolve}: 𝓛[ty]8696{Function};
 𝓟100{reject}: 𝓛[ty]8696{Function};
}

Module: packages/junctions/src/JunctionTemplate

type 𝓟[ty]2616{JunctionTemplate} extends 𝓟[ty]2578{TemplateBase} = {children: any, templateType: 𝓛[ty]10051{String}, compiledPatterns: 𝓛[ty]8670{Array}, meta: any, component: any, CONSTRUCTOR: (𝓟[ty]2570{MatcherOptions})->𝓟[ty]121{JunctionMatcher}}
type 𝓟[ty]2567{Helpers} = {split: any}
const 𝓟103{type}: 𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟104{templateType}: 𝓛[ty]10051{String} = 𝓛8743{String};
function 𝓟105{CONSTRUCTOR} (𝓟106{options}: [OOV]𝓟[ty]2570{MatcherOptions}): (𝓟[ty]121{JunctionMatcher})
{
 const 𝓟[ty]121{JunctionMatcher};
 const 𝓟[ty]121{JunctionMatcher};
 𝓟[ty]121{JunctionMatcher}(𝓟106{options})
 if (𝓟[ty]121{JunctionMatcher}.match)
 {
 let 𝓟110{remainingLocation}: [OOV]𝓟[ty]2586{Location} = (𝓟[ty]121{JunctionMatcher}.match.remainingLocation ? 𝓟[ty]121{JunctionMatcher}.match.remainingLocation : {pathname: 𝓛8743{String}};
 let 𝓟111{compiledPatterns}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]121{JunctionMatcher}.constructor.compiledPatterns;
 {
 let 𝓟112{i}: [miss]𝓛[ty]8655{Number} = 𝓟111{compiledPatterns}.length.MinusToken(𝓛8745{Number});
 while (𝓟112{i}.GreaterThanEqualsToken(𝓛8745{Number}))
 {
 {
 let 𝓟113{childMountedPattern}: [OOV]𝓟[ty]2569{MountedPattern} = 𝓟38{createChildMountedPattern}(𝓟[ty]121{JunctionMatcher}.mountedPattern,𝓟111{compiledPatterns}.access(𝓟112{i}));
 let 𝓟114{match}: [OOV]𝓟[ty]2563{PatternMatch} = 𝓟64{matchMountedPatternAgainstLocation}(𝓟113{childMountedPattern},𝓟110{remainingLocation});
 if (𝓟114{match})
 {
 𝓟[ty]121{JunctionMatcher}.childMountedPattern ⟵ 𝓟113{childMountedPattern};
 let 𝓟115{childMatcherOptions}: [miss]𝓛[ty]8642{Object} = {parentLocationPart: 𝓟[ty]121{JunctionMatcher}.segmentLocation,onChange: 𝓟[ty]121{JunctionMatcher}.handleChange,routerConfig: 𝓟[ty]121{JunctionMatcher}.routerConfig,matchableLocationPart: 𝓟110{remainingLocation},shouldFetchContent: 𝓟[ty]121{JunctionMatcher}.shouldFetchContent,mountedPattern: 𝓟[ty]121{JunctionMatcher}.childMountedPattern};
 if (𝓟113{childMountedPattern}.template.type.EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 𝓟[ty]121{JunctionMatcher}.childMatcher ⟵ 𝓟113{childMountedPattern}.template.CONSTRUCTOR(𝓟115{childMatcherOptions});
 𝓟[ty]121{JunctionMatcher}.childStatus ⟵ 𝓛8743{String};
 }
 else
 {
 if (𝓟113{childMountedPattern}.template.value)
 {
 𝓟[ty]121{JunctionMatcher}.childMatcher ⟵ 𝓟113{childMountedPattern}.template.value.CONSTRUCTOR(𝓟115{childMatcherOptions});
 𝓟[ty]121{JunctionMatcher}.childStatus ⟵ 𝓛8743{String};
 }
 else
 {
 function 𝓟116{$Lambda17} (𝓟117{status},𝓟118{value},𝓟119{error}): (𝓟120: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟118{value})
 {
 𝓟[ty]121{JunctionMatcher}.childMatcher ⟵ 𝓟118{value}.CONSTRUCTOR(𝓟115{childMatcherOptions});
 }
 𝓟[ty]121{JunctionMatcher}.childStatus ⟵ 𝓟117{status};
 𝓟[ty]121{JunctionMatcher}.childError ⟵ 𝓟119{error};
 }
 𝓟[ty]121{JunctionMatcher}.watchAsync(𝓟113{childMountedPattern}.template,{type: 𝓛8743{String},location: 𝓟729{concatLocations}(𝓟[ty]121{JunctionMatcher}.segmentLocation,𝓟114{match}.matchedLocation)},𝓟116{$Lambda17})
 }
 }
 }
 }
 𝓛12555{POST_MinusMinusToken}(𝓟112{i})
 }
 }
 }
}
class 𝓟[ty]121{JunctionMatcher} extends 𝓟[ty]641{Matcher}{
 𝓟123{childMatcher}: [OOV]𝓟[ty]641{Matcher};
 𝓟124{$ComputedPropertyName}: [OOV]𝓟[ty]2616{JunctionTemplate};
 𝓟125{childStatus}: [OOV]any;
 𝓟126{childMountedPattern}: [OOV]𝓟[ty]2569{MountedPattern};
 𝓟127{childError}: [OOV]any;
 function 𝓟128{willUnmount} (): (𝓟129: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟[ty]121{JunctionMatcher}.childMatcher)
 {
 𝓟[ty]121{JunctionMatcher}.childMatcher.willUnmount()
 }
 𝓟[ty]121{JunctionMatcher}.willUnmount()
 }
 function 𝓟130{isBusy} (): (𝓟131: 𝓛[ty]8666{Boolean})
 {
 return 𝓟131 = 𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟[ty]121{JunctionMatcher}.waitingForWatch)).BarBarToken(𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟[ty]121{JunctionMatcher}.childMatcher.AmpersandAmpersandToken(𝓟[ty]121{JunctionMatcher}.childMatcher.isBusy()))))
 }
 function 𝓟132{getRoute} (): (𝓟133: [OOV]any)
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]121{JunctionMatcher}.match))
 {
 }
 else
 {
 let 𝓟134{status}: [OOV]any;
 let 𝓟135{descendents}: [OOV]𝓟[ty]2583{JunctionDescendentSegments} = 𝓛8757{Array}() as any;
 if (𝓛12548{ExclamationToken}(𝓟[ty]121{JunctionMatcher}.childMountedPattern))
 {
 𝓟134{status} ⟵ 𝓛8743{String};
 }
 else
 {
 if (𝓟[ty]121{JunctionMatcher}.childStatus.EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 let 𝓟136{childRoute}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]121{JunctionMatcher}.childMatcher as 𝓟[ty]641{Matcher}.getRoute();
 if (𝓟136{childRoute})
 {
 𝓟135{descendents} ⟵ 𝓟136{childRoute};
 𝓟134{status} ⟵ 𝓛8743{String};
 }
 else
 {
 𝓟134{status} ⟵ 𝓛8743{String};
 }
 }
 else
 {
 𝓟134{status} ⟵ 𝓟[ty]121{JunctionMatcher}.childStatus;
 }
 }
 let 𝓟137{route}: [OOV]𝓟[ty]2590{JunctionRoute} = 𝓛8757{Array}(𝓟[ty]121{JunctionMatcher}.createSegment(𝓛8743{String},{children: 𝓟[ty]121{JunctionMatcher}.constructor.children,activeRoute: 𝓟135{descendents},meta: 𝓟[ty]121{JunctionMatcher}.constructor.meta,activePattern: 𝓟[ty]121{JunctionMatcher}.childMountedPattern.AmpersandAmpersandToken(𝓟[ty]121{JunctionMatcher}.childMountedPattern.relativePattern),activeChild: 𝓟135{descendents}.access(𝓛8745{Number}).BarBarToken(𝓛8744{Boolean}),status: 𝓟134{status},component: 𝓟[ty]121{JunctionMatcher}.constructor.component}));
 𝓟137{route}.push(𝓛12551{$Spread}(𝓟135{descendents}))
 return 𝓟133 = 𝓟137{route}
 }
 }
}
function 𝓟138{createJunctionTemplate} (𝓟139{getOptions}: [OOV]any): (𝓟140: [OOV]𝓟[ty]2616{JunctionTemplate})
{
 let 𝓟141{helpers}: [miss]𝓛[ty]8642{Object} = {split: 𝓟171{split}};
 let 𝓟142{options}: [miss]𝓛[ty]8642{Object} = (𝓛12550{$TypeOf}(𝓟139{getOptions}).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟139{getOptions}(𝓟141{helpers}) : 𝓟139{getOptions};
 if (𝓛12548{ExclamationToken}(𝓟142{options}))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 if (𝓛12548{ExclamationToken}(𝓟142{options}.children))
 {
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 𝓟142{options}.children ⟵ {} as any;
 }
 function 𝓟143{$Lambda18} (𝓟144{pattern}): (𝓟145: [OOV]𝓟[ty]2568{CompiledPattern})
 {
 return 𝓟145 = 𝓟27{compilePattern}(𝓟144{pattern},𝓟142{options}.children.access(𝓟144{pattern}))
 }
 function 𝓟146{$Lambda19} (𝓟147{x},𝓟148{y}): (𝓟149: [OOV]any)
 {
 return 𝓟149 = 𝓟174{compareStrings}(𝓟147{x}.relativeKey,𝓟148{y}.relativeKey)
 }
 let 𝓟150{compiledPatterns}: [miss]𝓛[ty]8670{Array} = 𝓛8741{Object}.keys(𝓟142{options}.children).map(𝓟143{$Lambda18}).sort(𝓟146{$Lambda19});
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 let 𝓟151{children}: [OOV]any = 𝓟142{options}.children;
 let 𝓟152{meta}: [OOV]any = 𝓟142{options}.meta;
 let 𝓟153{params}: [miss]𝓛[ty]8670{Array} = 𝓟142{options}.params;
 let 𝓟154{component}: [OOV]any = 𝓟142{options}.component;
 let 𝓟155{other}: [miss]𝓛[ty]8642{Object} = 𝓟142{options}.other;
 if (𝓛12548{ExclamationToken}(𝓛8743{String}.InKeyword(𝓟142{options})))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 let 𝓟156{unknownKeys}: [miss]𝓛[ty]8670{Array} = 𝓛8741{Object}.keys(𝓟155{other});
 if (𝓟156{unknownKeys}.length)
 {
 function 𝓟157{$Lambda20} (𝓟158{x}): (𝓟159: [miss]𝓛[ty]10051{String})
 {
 return 𝓟159 = 𝓛12554{$Template}(𝓟158{x})
 }
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟156{unknownKeys}.map(𝓟157{$Lambda20}).join(𝓛8743{String})))
 }
 if (𝓟150{compiledPatterns}.length.EqualsEqualsEqualsToken(𝓛8745{Number}))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 let 𝓟160{len}: [miss]𝓛[ty]8655{Number} = 𝓟150{compiledPatterns}.length;
 if (𝓟150{compiledPatterns}.length.GreaterThanEqualsToken(𝓛8745{Number}))
 {
 let 𝓟161{previousPattern}: [OOV]𝓟[ty]2568{CompiledPattern} = 𝓟150{compiledPatterns}.access(𝓟160{len}.MinusToken(𝓛8745{Number}));
 {
 let 𝓟162{i}: [miss]𝓛[ty]8655{Number} = 𝓟160{len}.MinusToken(𝓛8745{Number});
 while (𝓟162{i}.GreaterThanEqualsToken(𝓛8745{Number}))
 {
 {
 let 𝓟163{pattern}: [OOV]𝓟[ty]2568{CompiledPattern} = 𝓟150{compiledPatterns}.access(𝓟162{i});
 let 𝓟164{replacedKey}: [miss]𝓛[ty]10051{String} = 𝓟163{pattern}.relativeKey.replace(𝓟161{previousPattern}.relativeRegExp,𝓛8743{String});
 if (𝓟164{replacedKey}.ExclamationEqualsEqualsToken(𝓟163{pattern}.relativeKey).AmpersandAmpersandToken(𝓟164{replacedKey}.length.GreaterThanToken(𝓛8745{Number})))
 {
 if (𝓟161{previousPattern}.template.type.EqualsEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟161{previousPattern}.template.templateType.EqualsEqualsEqualsToken(𝓛8743{String})).BarBarToken(𝓟163{pattern}.template.type.EqualsEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟163{pattern}.template.templateType.EqualsEqualsEqualsToken(𝓛8743{String}))))
 {
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟161{previousPattern}.relativePattern,𝓟163{pattern}.relativePattern))
 }
 }
 𝓟161{previousPattern} ⟵ 𝓟163{pattern};
 }
 𝓛12555{POST_MinusMinusToken}(𝓟162{i})
 }
 }
 }
 {
 let 𝓟165{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓟165{i}.FirstBinaryOperator(𝓟160{len}))
 {
 {
 if (𝓛12548{ExclamationToken}(𝓟150{compiledPatterns}.access(𝓟165{i}).template))
 {
 let 𝓟166{pattern}: [miss]𝓛[ty]10051{String} = 𝓟150{compiledPatterns}.access(𝓟165{i}).relativePattern;
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓛12550{$TypeOf}(𝓟150{compiledPatterns}.access(𝓟165{i}).template),𝓟166{pattern}))
 }
 }
 𝓛12546{POST_PlusPlusToken}(𝓟165{i})
 }
 }
 function 𝓟167{$Lambda21} (𝓟168{pattern}): (𝓟169: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟169 = 𝓟168{pattern}.relativeKey.EqualsEqualsEqualsToken(𝓛8743{String})
 }
 let 𝓟170{indexPattern}: [OOV]𝓟[ty]2568{CompiledPattern} = 𝓟150{compiledPatterns}.find(𝓟167{$Lambda21});
 if (𝓟170{indexPattern})
 {
 if (𝓟170{indexPattern}.template.type.EqualsEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟170{indexPattern}.template.templateType.EqualsEqualsEqualsToken(𝓛8743{String})))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 }
 }
 return 𝓟140 = 𝓛12563{undefined}
}
function 𝓟171{split} (𝓟172{getter}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function})): (𝓟173: [OOV]𝓟[ty]613{AsyncObjectContainer})
{
 return 𝓟173 = {type: 𝓛8743{String},status: 𝓛12563{undefined},getter: 𝓟172{getter},value: 𝓛12563{undefined} as any}
}
function 𝓟174{compareStrings} (𝓟175{a},𝓟176{b}): (𝓟177: [OOV]any)
{
 return 𝓟177 = (𝓟175{a}.FirstBinaryOperator(𝓟176{b}) ? 𝓛12557{MinusToken}(𝓛8745{Number}) : (𝓟175{a}.GreaterThanToken(𝓟176{b}) ? 𝓛8745{Number} : 𝓛8745{Number}
}

Module: packages/junctions/src/ContentHelpers

type 𝓟[ty]2581{JunctionMapPredicate} = (any)->𝓛[ty]8666{Boolean}
type 𝓟[ty]2608{PageMap} = {access: (𝓛[ty]10051{String})->𝓟[ty]2597{Page}}
type 𝓟[ty]2595{ContentHelpers} = {getPages: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, getRouteSegment: (𝓛[ty]10051{String})->𝓛[ty]8654{Promise}, getPageMap: (𝓟[ty]2609{Junction},𝓟[ty]2581{JunctionMapPredicate})->𝓛[ty]8654{Promise}}
function 𝓟181{$Lambda10} (𝓟182{segment}: [OOV]any): (𝓟183: [miss]𝓛[ty]8666{Boolean})
{
 return 𝓟183 = 𝓛8744{Boolean}
}
const 𝓟184{defaultPredicate}: [miss]𝓛[ty]8696{Function} = 𝓟181{$Lambda10};
function 𝓟185{createContentHelpers} (𝓟186{routerConfig}: [OOV]𝓟[ty]2574{RouterConfig}): (𝓟187: [OOV]𝓟[ty]2595{ContentHelpers})
{
 function 𝓟188{getPages} (𝓟189{pathnames}: [OOV]any): (𝓟190: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8654{Promise}))
 {
 }
 function 𝓟191{getPages} (𝓟192{pathname}: 𝓛[ty]10051{String}): (𝓟193: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8654{Promise}))
 {
 }
 function 𝓟194{getPages} (𝓟195{pathnames}: [OOV]any): (𝓟196: [OOV]any)
 {
 if (𝓛12550{$TypeOf}(𝓟195{pathnames}).EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 function 𝓟197{$Lambda11} (𝓟198{page}): (𝓟199: [miss]𝓛[ty]8654{Promise})
 {
 return 𝓟199 = (𝓟198{page} ? 𝓛1062{Promise}.resolve(𝓟198{page}) : 𝓛1062{Promise}.reject(𝓛12563{undefined})
 }
 return 𝓟196 = 𝓟234{getPageNode}({pathname: 𝓟195{pathnames}}).then(𝓟197{$Lambda11})
 }
 else
 {
 let 𝓟200{keys}: [miss]𝓛[ty]8670{Array} = 𝓛8741{Object}.keys(𝓟195{pathnames});
 let 𝓟201{promises}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
 {
 let 𝓟202{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓟202{i}.FirstBinaryOperator(𝓟200{keys}.length))
 {
 {
 let 𝓟203{key}: [miss]𝓛[ty]10051{String} = 𝓟200{keys}.access(𝓟202{i});
 𝓟201{promises}.push(𝓟234{getPageNode}({pathname: 𝓟195{pathnames}.access(𝓟203{key})}))
 }
 𝓛12546{POST_PlusPlusToken}(𝓟202{i})
 }
 }
 function 𝓟204{$Lambda12} (𝓟205{values}): (𝓟206: [miss]𝓛[ty]8654{Promise})
 {
 let 𝓟207{result} = {} as any;
 {
 let 𝓟208{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓟208{i}.FirstBinaryOperator(𝓟200{keys}.length))
 {
 {
 let 𝓟209{value}: [OOV]𝓟[ty]2597{Page} = 𝓟205{values}.access(𝓟208{i});
 if (𝓟209{value}.EqualsEqualsEqualsToken(𝓛12563{undefined}))
 {
 return 𝓟206 = 𝓛1062{Promise}.reject(𝓛12563{undefined})
 }
 𝓟207{result}.access(𝓟200{keys}.access(𝓟208{i})) ⟵ 𝓟209{value};
 }
 𝓛12546{POST_PlusPlusToken}(𝓟208{i})
 }
 }
 return 𝓟206 = 𝓛1062{Promise}.resolve(𝓟207{result})
 }
 return 𝓟196 = 𝓛1062{Promise}.all(𝓟201{promises}).then(𝓟204{$Lambda12})
 }
 }
 function 𝓟210{getRouteSegment} (𝓟211{pathname}: 𝓛[ty]10051{String}): (𝓟212: 𝓛[ty]8654{Promise})
 {
 let 𝓟213{deferred}: [OOV]𝓟[ty]96{Deferred} = 𝓟88{CONSTRUCTOR}();
 let 𝓟214{searchLocation}: [miss]𝓛[ty]8642{Object} = {pathname: (𝓟211{pathname}.substr(𝓛12557{MinusToken}(𝓛8745{Number})).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟211{pathname} : 𝓟211{pathname}.PlusToken(𝓛8743{String})};
 function 𝓟215{$Lambda13} (𝓟216{route}: [OOV]𝓟[ty]2587{Route}): (𝓟217: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟216{route})
 {
 let 𝓟218{lastSegment}: [OOV]𝓛[ty]0{ANY} = 𝓟216{route}.access(𝓟216{route}.length.MinusToken(𝓛8745{Number}));
 if (𝓟218{lastSegment}.location.pathname.EqualsEqualsEqualsToken(𝓟211{pathname}))
 {
 𝓟213{deferred}.resolve(𝓟218{lastSegment})
 }
 else
 {
 if (𝓟218{lastSegment}.location.pathname.EqualsEqualsEqualsToken(𝓟211{pathname}.PlusToken(𝓛8743{String})))
 {
 let 𝓟219{lastJunction}: [OOV]𝓛[ty]0{ANY} = 𝓟216{route}.access(𝓟216{route}.length.MinusToken(𝓛8745{Number}));
 if (𝓟219{lastJunction})
 {
 𝓟213{deferred}.resolve(𝓟219{lastJunction})
 }
 }
 }
 }
 𝓟213{deferred}.reject(𝓛12563{undefined})
 }
 𝓟242{processFinalNodeWithoutContent}(𝓟214{searchLocation},𝓟215{$Lambda13})
 return 𝓟212 = 𝓟213{deferred}.promise
 }
 function 𝓟220{$Async_getPageMap} (𝓟221{junction}: [OOV]𝓟[ty]2609{Junction},𝓟222{predicate}: [OOV]𝓟[ty]2581{JunctionMapPredicate}): (𝓟223: 𝓛[ty]8654{Promise})
 {
 let 𝓟224{map}: [OOV]𝓟[ty]2608{PageMap} = {} as 𝓟[ty]2608{PageMap};
 let 𝓟225{template}: [OOV]𝓟[ty]2616{JunctionTemplate} = 𝓟221{junction}.template as 𝓟[ty]2616{JunctionTemplate};
 let 𝓟226{children}: [miss]𝓛[ty]8670{Array} = 𝓛8741{Object}.entries(𝓟225{template}.children) as 𝓛[ty]8670{Array};
 let 𝓟227{possiblePromises}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}() as 𝓛[ty]8670{Array};
 let 𝓟228{queue}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓟221{junction});
 while (𝓟228{queue}.length)
 {
 let 𝓟229{junction}: [OOV]𝓟[ty]2609{Junction} = 𝓟228{queue}.shift() as 𝓟[ty]2609{Junction};
 {
 let 𝓟230{pattern}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓛12552{$ArrayAccess}(𝓟226{children}));
 let 𝓟231{template} = 𝓛12552{$ArrayAccess}(𝓛12552{$ArrayAccess}(𝓟226{children}));
 while (𝓛8744{Boolean})
 {
 let 𝓟232{path}: [miss]𝓛[ty]10051{String} = 𝓟229{junction}.location.pathname.PlusToken(𝓟230{pattern});
 let 𝓟233{segment}: [OOV]𝓛[ty]0{ANY} = 𝓛12547{$Await}(𝓟210{getRouteSegment}(𝓟232{path}));
 if (𝓟233{segment}.type.ExclamationEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟222{predicate}(𝓟233{segment})))
 {
 if (𝓟233{segment}.type.EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 𝓟228{queue}.push(𝓟229{junction})
 }
 else
 {
 𝓟224{map}.access(𝓟232{path}) ⟵ 𝓟233{segment};
 }
 }
 }
 }
 }
 return 𝓟223 = 𝓟224{map}
 }
 function 𝓟234{getPageNode} (𝓟235{location}: [OOV]𝓟[ty]2586{Location}): (𝓟236: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8654{Promise}))
 {
 let 𝓟237{deferred}: [OOV]𝓟[ty]96{Deferred} = 𝓟88{CONSTRUCTOR}();
 function 𝓟238{$Lambda14} (𝓟239{route}: [OOV]𝓟[ty]2590{JunctionRoute}): (𝓟240: [miss]𝓛[ty]10033{Void})
 {
 let 𝓟241{lastSegment}: [OOV]𝓛[ty]0{ANY} = 𝓟239{route}.AmpersandAmpersandToken(𝓟239{route}.access(𝓟239{route}.length.MinusToken(𝓛8745{Number})));
 if (𝓛12548{ExclamationToken}(𝓟241{lastSegment}).BarBarToken(𝓟241{lastSegment}.type.EqualsEqualsEqualsToken(𝓛8743{String})))
 {
 𝓟237{deferred}.resolve(𝓛12563{undefined})
 }
 else
 {
 if (𝓟241{lastSegment}.type.EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 return 𝓟240 = 𝓟237{deferred}.resolve(𝓟241{lastSegment})
 }
 else
 {
 𝓟234{getPageNode}(𝓟241{lastSegment}.to).then(𝓟237{deferred}.resolve)
 }
 }
 }
 𝓟242{processFinalNodeWithoutContent}(𝓟235{location},𝓟238{$Lambda14})
 return 𝓟236 = 𝓟237{deferred}.promise
 }
 function 𝓟242{processFinalNodeWithoutContent} (𝓟243{location}: [OOV]𝓟[ty]2586{Location},𝓟244{callback}: 𝓛[ty]8696{Function}): (𝓟245: [miss]𝓛[ty]10033{Void})
 {
 let 𝓟246{match}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟64{matchMountedPatternAgainstLocation}(𝓟186{routerConfig}.rootMountedPattern,𝓟243{location});
 if (𝓛12548{ExclamationToken}(𝓟246{match}))
 {
 𝓟244{callback}()
 }
 else
 {
 let 𝓟247{deferred}: [OOV]𝓟[ty]96{Deferred} = 𝓟88{CONSTRUCTOR}();
 function 𝓟248{$Lambda15} (): (𝓟249: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12548{ExclamationToken}(𝓟251{rootMatcher}.isBusy()))
 {
 𝓟244{callback}(𝓟251{rootMatcher}.getRoute())
 𝓟251{rootMatcher}.willUnmount()
 }
 }
 const 𝓟250{handleRouteChange}: [miss]𝓛[ty]8696{Function} = 𝓟248{$Lambda15};
 let 𝓟251{rootMatcher}: [OOV]𝓟[ty]121{JunctionMatcher} = 𝓟186{routerConfig}.rootJunctionTemplate.CONSTRUCTOR({parentLocationPart: {pathname: 𝓛8743{String}},onChange: 𝓟250{handleRouteChange},routerConfig: 𝓟186{routerConfig},matchableLocationPart: 𝓟243{location},shouldFetchContent: 𝓛8744{Boolean},mountedPattern: 𝓟186{routerConfig}.rootMountedPattern});
 𝓟250{handleRouteChange}()
 }
 }
 return 𝓟187 = {getPages: 𝓟194{getPages},getRouteSegment: 𝓟210{getRouteSegment},getPageMap: 𝓛1{<UNKNOWN>}}
}

Module: packages/junctions/src/StaticNavigation

function 𝓟252{CONSTRUCTOR} (𝓟253{options}: 𝓛[ty]8642{Object}): (𝓟[ty]260{StaticNavigation})
{
 const 𝓟[ty]260{StaticNavigation};
 const 𝓟[ty]260{StaticNavigation};
 function 𝓟257{$Lambda33} (): (𝓟258: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]260{StaticNavigation}.router.isBusy()))
 {
 𝓟[ty]260{StaticNavigation}.finalRootRouteDeferred.resolve(𝓟[ty]260{StaticNavigation}.router.getRoute())
 }
 }
 𝓟[ty]260{StaticNavigation}.handleRouteChange ⟵ 𝓟257{$Lambda33};
 let 𝓟259{config}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟83{createRouterConfig}({rootJunctionTemplate: 𝓟253{options}.rootJunctionTemplate});
 𝓛8741{Object}.assign(𝓟[ty]260{StaticNavigation},𝓟185{createContentHelpers}(𝓟259{config}))
 𝓟[ty]260{StaticNavigation}.location ⟵ 𝓟253{options}.location;
 𝓟[ty]260{StaticNavigation}.finalRootRouteDeferred ⟵ 𝓟88{CONSTRUCTOR}();
 𝓟[ty]260{StaticNavigation}.router ⟵ 𝓟284{CONSTRUCTOR}(𝓟259{config});
 𝓟[ty]260{StaticNavigation}.router.subscribe(𝓟[ty]260{StaticNavigation}.handleRouteChange)
 𝓟[ty]260{StaticNavigation}.router.setLocation(𝓟253{options}.location)
}
class 𝓟[ty]260{StaticNavigation} extends 𝓟[ty]2622{Navigation}{
 𝓟262{location}: [OOV]𝓟[ty]2586{Location};
 𝓟263{getPages}: [OOV]any;
 𝓟264{finalRootRouteDeferred}: [OOV]𝓟[ty]96{Deferred};
 𝓟265{handleRouteChange}: [miss]𝓛[ty]8696{Function};
 𝓟266{router}: [OOV]𝓟[ty]292{Router};
 function 𝓟278{pushLocation} (𝓟279{x}: [OOV]any,𝓟280{y}: [OOV]any): (𝓟281: [miss]𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 function 𝓟271{block} (𝓟272{message}: 𝓛[ty]10051{String}): (𝓟273: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8696{Function}))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 function 𝓟267{getFinalRoute} (): (𝓟268: 𝓛[ty]8654{Promise})
 {
 return 𝓟268 = 𝓟[ty]260{StaticNavigation}.finalRootRouteDeferred.promise
 }
 function 𝓟269{getLocation} (): (𝓟270: [OOV]𝓟[ty]2586{Location})
 {
 return 𝓟270 = 𝓟[ty]260{StaticNavigation}.location
 }
 function 𝓟274{replaceLocation} (𝓟275{x}: [OOV]any,𝓟276{y}: [OOV]any): (𝓟277: [miss]𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
}

Module: packages/junctions/src/Router

type 𝓟[ty]2560{UnsubscribeCallback} = ()->𝓛[ty]10033{Void}
type 𝓟[ty]2560{UnsubscribeCallback} = ()->𝓛[ty]10033{Void}
function 𝓟284{CONSTRUCTOR} (𝓟285{config}: [OOV]𝓟[ty]2574{RouterConfig}): (𝓟[ty]292{Router})
{
 const 𝓟[ty]292{Router};
 const 𝓟[ty]292{Router};
 function 𝓟289{$Lambda31} (): (𝓟290: [miss]𝓛[ty]10033{Void})
 {
 {
 let 𝓟291{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓟291{i}.FirstBinaryOperator(𝓟[ty]292{Router}.listeners.length))
 {
 {
 𝓟[ty]292{Router}.listeners.access(𝓟291{i})()
 }
 𝓛12546{POST_PlusPlusToken}(𝓟291{i})
 }
 }
 }
 𝓟[ty]292{Router}.listeners ⟵ 𝓛8757{Array}();
 𝓟[ty]292{Router}.notifyListeners ⟵ 𝓟289{$Lambda31};
 𝓟[ty]292{Router}.listeners ⟵ 𝓛8757{Array}();
 𝓟[ty]292{Router}.config ⟵ 𝓟285{config};
}
class 𝓟[ty]292{Router}{
 𝓟294{location}: [OOV]𝓟[ty]2586{Location};
 𝓟295{notifyListeners}: [miss]𝓛[ty]8696{Function};
 𝓟296{listeners}: 𝓛[ty]8670{Array};
 𝓟297{rootMatcher}: [OOV]any;
 𝓟298{config}: [OOV]𝓟[ty]2574{RouterConfig};
 function 𝓟299{getRoute} (): (𝓟300: [OOV]any)
 {
 return 𝓟300 = 𝓟[ty]292{Router}.rootMatcher.AmpersandAmpersandToken(𝓟[ty]292{Router}.rootMatcher.getRoute())
 }
 function 𝓟301{subscribe} (𝓟302{onRouteChange}: [OOV]𝓟[ty]2560{UnsubscribeCallback}): (𝓟303: [OOV]𝓟[ty]2560{UnsubscribeCallback})
 {
 𝓟[ty]292{Router}.listeners.push(𝓟302{onRouteChange})
 function 𝓟304{$Lambda30} (): (𝓟305: [miss]𝓛[ty]10033{Void})
 {
 let 𝓟306{index}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]292{Router}.listeners.indexOf(𝓟302{onRouteChange});
 if (𝓟306{index}.ExclamationEqualsEqualsToken(𝓛12557{MinusToken}(𝓛8745{Number})))
 {
 𝓟[ty]292{Router}.listeners.splice(𝓟306{index},𝓛8745{Number})
 }
 }
 return 𝓟303 = 𝓟304{$Lambda30}
 }
 function 𝓟307{isBusy} (): (𝓟308: [miss]𝓛[ty]8666{Boolean})
 {
 if (𝓟[ty]292{Router}.rootMatcher)
 {
 return 𝓟308 = 𝓟[ty]292{Router}.rootMatcher.isBusy()
 }
 return 𝓟308 = 𝓛8744{Boolean}
 }
 function 𝓟309{setLocation} (𝓟310{location}: [OOV]𝓟[ty]2586{Location}): (𝓟311: 𝓛[ty]10033{Void})
 {
 let 𝓟312{locationExistenceHasChanged} = 𝓟310{location}.AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟[ty]292{Router}.location)).BarBarToken(𝓛12548{ExclamationToken}(𝓟310{location}).AmpersandAmpersandToken(𝓟[ty]292{Router}.location));
 let 𝓟313{pathHasChanged};
 let 𝓟314{searchHasChanged};
 if (𝓟310{location}.AmpersandAmpersandToken(𝓟[ty]292{Router}.location))
 {
 𝓟313{pathHasChanged} ⟵ 𝓟310{location}.pathname.ExclamationEqualsEqualsToken(𝓟[ty]292{Router}.location.pathname);
 𝓟314{searchHasChanged} ⟵ 𝓟310{location}.search.ExclamationEqualsEqualsToken(𝓟[ty]292{Router}.location.search);
 }
 if (𝓛12548{ExclamationToken}(𝓟313{pathHasChanged}.BarBarToken(𝓟314{searchHasChanged}).BarBarToken(𝓟312{locationExistenceHasChanged})))
 {
 𝓟[ty]292{Router}.notifyListeners()
 }
 𝓟[ty]292{Router}.location ⟵ 𝓟310{location};
 let 𝓟315{match}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟310{location}.AmpersandAmpersandToken(𝓟64{matchMountedPatternAgainstLocation}(𝓟[ty]292{Router}.config.rootMountedPattern,𝓟310{location}));
 if (𝓛12548{ExclamationToken}(𝓟315{match}).AmpersandAmpersandToken(𝓟[ty]292{Router}.rootMatcher))
 {
 𝓟[ty]292{Router}.rootMatcher.willUnmount()
 𝓟[ty]292{Router}.rootMatcher ⟵ 𝓛12563{undefined};
 𝓟[ty]292{Router}.notifyListeners()
 }
 else
 {
 if (𝓟310{location}.AmpersandAmpersandToken(𝓟315{match}))
 {
 if (𝓟[ty]292{Router}.rootMatcher)
 {
 𝓟[ty]292{Router}.rootMatcher.willUnmount()
 }
 𝓟[ty]292{Router}.rootMatcher ⟵ 𝓟[ty]292{Router}.config.rootJunctionTemplate.CONSTRUCTOR({parentLocationPart: {pathname: 𝓛8743{String}},onChange: 𝓟[ty]292{Router}.notifyListeners,routerConfig: 𝓟[ty]292{Router}.config,matchableLocationPart: 𝓟310{location},shouldFetchContent: 𝓛8744{Boolean},mountedPattern: 𝓟[ty]292{Router}.config.rootMountedPattern});
 𝓟[ty]292{Router}.notifyListeners()
 }
 }
 }
}

Module: packages/junctions/src/PageTemplate

type 𝓟[ty]2572{PageTemplate} extends 𝓟[ty]2578{TemplateBase} = {templateType: 𝓛[ty]10051{String}, meta: any, contentContainer: 𝓟[ty]2599{AsyncObjectContainer}, title: 𝓛[ty]10051{String}, component: any, CONSTRUCTOR: (𝓟[ty]2570{MatcherOptions})->𝓟[ty]331{PageMatcher}}
type 𝓟[ty]2599{AsyncObjectContainer} = 𝓟[ty]2599{AsyncObjectContainer}
const 𝓟318{type}: 𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟319{templateType}: 𝓛[ty]10051{String} = 𝓛8743{String};
function 𝓟320{CONSTRUCTOR} (𝓟321{options}: [OOV]𝓟[ty]2570{MatcherOptions}): (𝓟[ty]331{PageMatcher})
{
 const 𝓟[ty]331{PageMatcher};
 const 𝓟[ty]331{PageMatcher};
 𝓟[ty]331{PageMatcher}(𝓟321{options})
 if (𝓟[ty]331{PageMatcher}.match)
 {
 let 𝓟325{remainingLocation}: [OOV]𝓟[ty]2586{Location} = 𝓟[ty]331{PageMatcher}.match.remainingLocation;
 if (𝓟325{remainingLocation}.AmpersandAmpersandToken(𝓟325{remainingLocation}.pathname.ExclamationEqualsEqualsToken(𝓛8743{String})))
 {
 𝓛12560{$Delete}(𝓟[ty]331{PageMatcher}.match)
 }
 else
 {
 if (𝓟[ty]331{PageMatcher}.match.AmpersandAmpersandToken(𝓟[ty]331{PageMatcher}.shouldFetchContent))
 {
 function 𝓟326{$Lambda22} (𝓟327{status},𝓟328{value},𝓟329{error}): (𝓟330: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]331{PageMatcher}.content ⟵ 𝓟328{value};
 𝓟[ty]331{PageMatcher}.contentStatus ⟵ 𝓟327{status};
 𝓟[ty]331{PageMatcher}.contentError ⟵ 𝓟329{error};
 }
 𝓟[ty]331{PageMatcher}.watchAsync(𝓟[ty]331{PageMatcher}.constructor.contentContainer,{type: 𝓛8743{String},location: 𝓟[ty]331{PageMatcher}.segmentLocation},𝓟326{$Lambda22})
 }
 }
 }
}
class 𝓟[ty]331{PageMatcher} extends 𝓟[ty]641{Matcher}{
 𝓟333{content}: [OOV]any;
 𝓟334{contentStatus}: [OOV]any;
 𝓟335{contentError}: [OOV]any;
 𝓟336{$ComputedPropertyName}: [OOV]𝓟[ty]2572{PageTemplate};
 function 𝓟337{getRoute} (): (𝓟338: [OOV]any)
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]331{PageMatcher}.match))
 {
 }
 return 𝓟338 = 𝓛8757{Array}(𝓟[ty]331{PageMatcher}.createSegment(𝓛8743{String},{contentError: 𝓟[ty]331{PageMatcher}.contentError,contentStatus: 𝓟[ty]331{PageMatcher}.contentStatus,meta: 𝓟[ty]331{PageMatcher}.constructor.meta,content: 𝓟[ty]331{PageMatcher}.content,title: 𝓟[ty]331{PageMatcher}.constructor.title,component: 𝓟[ty]331{PageMatcher}.constructor.component}))
 }
}
function 𝓟339{createPageTemplate} (𝓟340{options}: 𝓛[ty]8642{Object}): (𝓟341: [OOV]𝓟[ty]2572{PageTemplate})
{
 let 𝓟342{getter}: 𝓛[ty]8696{Function};
 if (𝓟340{options}.getContent)
 {
 let 𝓟343{getContent}: [miss]𝓛[ty]8696{Function} = 𝓟340{options}.getContent;
 function 𝓟344{$Lambda23} (𝓟345{routerConfig}: [OOV]𝓟[ty]2574{RouterConfig}): (𝓟346: [OOV]any)
 {
 return 𝓟346 = 𝓟343{getContent}(𝓟185{createContentHelpers}(𝓟345{routerConfig}))
 }
 𝓟342{getter} ⟵ 𝓟344{$Lambda23};
 }
 else
 {
 function 𝓟347{$Lambda24} (): (𝓟348: [miss]𝓛[ty]10033{Void})
 {
 }
 𝓟342{getter} ⟵ 𝓟347{$Lambda24} as any;
 }
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 let 𝓟349{params}: [miss]𝓛[ty]8670{Array} = 𝓟340{options}.params;
 let 𝓟350{title}: [miss]𝓛[ty]10051{String} = 𝓟340{options}.title;
 let 𝓟351{component}: [OOV]any = 𝓟340{options}.component;
 let 𝓟352{meta}: [OOV]any = 𝓟340{options}.meta;
 let 𝓟353{getContent}: [miss]𝓛[ty]8696{Function} = 𝓟340{options}.getContent;
 let 𝓟354{other}: [miss]𝓛[ty]8642{Object} = 𝓟340{options}.other;
 if (𝓛12548{ExclamationToken}(𝓛8743{String}.InKeyword(𝓟340{options})))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 let 𝓟355{unknownKeys}: [miss]𝓛[ty]8670{Array} = 𝓛8741{Object}.keys(𝓟354{other});
 if (𝓟355{unknownKeys}.length)
 {
 function 𝓟356{$Lambda25} (𝓟357{x}): (𝓟358: [miss]𝓛[ty]10051{String})
 {
 return 𝓟358 = 𝓛12554{$Template}(𝓟357{x})
 }
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟355{unknownKeys}.map(𝓟356{$Lambda25}).join(𝓛8743{String})))
 }
 if (𝓟350{title}.EqualsEqualsEqualsToken(𝓛12563{undefined}))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 }
 let 𝓟359{contentContainer}: [OOV]𝓟[ty]2599{AsyncObjectContainer} = {type: 𝓛8743{String},status: 𝓛12563{undefined},getter: 𝓟342{getter},value: 𝓛12563{undefined} as any};
 return 𝓟341 = 𝓛12563{undefined}
}

Module: packages/react-junctions/src/Link

type 𝓟[ty]2612{LinkRendererProps} = {children: any, tabIndex: 𝓛[ty]8655{Number}, onFollow: ({preventDefault: ()->{}})->𝓛[ty]10033{Void}, style: 𝓛[ty]8642{Object}, cx: any, hidden: 𝓛[ty]8666{Boolean}, activeClassName: 𝓛[ty]10051{String}, id: 𝓛[ty]10051{String}, className: 𝓛[ty]10051{String}, activeStyle: 𝓛[ty]8642{Object}, disabled: 𝓛[ty]8666{Boolean}, target: 𝓛[ty]10051{String}, title: 𝓛[ty]10051{String}, lang: 𝓛[ty]10051{String}, href: 𝓛[ty]10051{String}, active: 𝓛[ty]8666{Boolean}}
type 𝓟[ty]2606{LinkProps} = {children: any, tabIndex: 𝓛[ty]8655{Number}, style: 𝓛[ty]8642{Object}, cx: any, hidden: 𝓛[ty]8666{Boolean}, activeClassName: 𝓛[ty]10051{String}, exact: 𝓛[ty]8666{Boolean}, id: 𝓛[ty]10051{String}, className: 𝓛[ty]10051{String}, activeStyle: 𝓛[ty]8642{Object}, disabled: 𝓛[ty]8666{Boolean}, target: 𝓛[ty]10051{String}, title: 𝓛[ty]10051{String}, lang: 𝓛[ty]10051{String}, render: (𝓟[ty]2612{LinkRendererProps})->any, href: any, env: {navigation: 𝓟[ty]2622{Navigation}}, active: 𝓛[ty]8666{Boolean}}
function 𝓟362{$Lambda43} (𝓟363{props}: [OOV]𝓟[ty]2612{LinkRendererProps}): (𝓟364: [OOV]any)
{
 return 𝓟364 = 𝓛12563{undefined}
}
const 𝓟365{defaultProps}: [miss]𝓛[ty]8642{Object} = {render: 𝓟362{$Lambda43}};
const 𝓟366{contextTypes}: [miss]𝓛[ty]8642{Object} = {navigation: 𝓛29738{object}};
function 𝓟367{CONSTRUCTOR} (𝓟368{props},𝓟369{context}): (𝓟[ty]380{Link})
{
 const 𝓟[ty]380{Link};
 const 𝓟[ty]380{Link};
 function 𝓟373{$Lambda45} (𝓟374{event}: 𝓛[ty]8642{Object}): (𝓟375: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟[ty]380{Link}.props.disabled)
 {
 𝓟374{event}.preventDefault()
 }
 let 𝓟376{location} = 𝓟[ty]380{Link}.getLocation();
 if (𝓟376{location})
 {
 𝓟374{event}.preventDefault()
 𝓟[ty]380{Link}.navigation.pushLocation(𝓟376{location})
 }
 }
 𝓟[ty]380{Link}.handleFollow ⟵ 𝓟373{$Lambda45};
 𝓟[ty]380{Link}(𝓟368{props},𝓟369{context})
 𝓟[ty]380{Link}.navigation ⟵ (𝓟[ty]380{Link}.props.env ? 𝓟[ty]380{Link}.props.env.navigation : 𝓟369{context}.navigation;
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]380{Link}.navigation).AmpersandAmpersandToken(𝓟[ty]380{Link}.getLocation()))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String}.PlusToken(𝓛8743{String}).PlusToken(𝓛8743{String}))
 }
 let 𝓟377{location} = 𝓟[ty]380{Link}.getLocation() as 𝓟[ty]2586{Location};
 if (𝓟377{location}.AmpersandAmpersandToken(𝓟377{location}.pathname))
 {
 function 𝓟378{$Lambda44} (): (𝓟379: [miss]𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟377{location}.pathname).PlusToken(𝓛8743{String}))
 }
 𝓟[ty]380{Link}.navigation.getPages(𝓟377{location}.pathname).catch(𝓟378{$Lambda44})
 }
 }
}
class 𝓟[ty]380{Link} extends 𝓛[ty]33520{Component}{
 𝓟382{navigation}: [OOV]𝓟[ty]2622{Navigation};
 𝓟383{handleFollow}: [miss]𝓛[ty]8696{Function};
 function 𝓟384{getLocation} (): (𝓟385: [OOV]any)
 {
 let 𝓟386{href} = 𝓟[ty]380{Link}.props.href;
 if (𝓛12548{ExclamationToken}(𝓟386{href}))
 {
 }
 if (𝓛12550{$TypeOf}(𝓟386{href}).ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 return 𝓟385 = 𝓟386{href}
 }
 if (𝓟386{href}.indexOf(𝓛8743{String}).ExclamationEqualsEqualsToken(𝓛12557{MinusToken}(𝓛8745{Number})).BarBarToken(𝓟386{href}.indexOf(𝓛8743{String}).EqualsEqualsEqualsToken(𝓛8745{Number})))
 {
 }
 let 𝓟387{lhs}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓟386{href}.split(𝓛8743{String}));
 let 𝓟388{hash}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓟386{href}.split(𝓛8743{String}));
 let 𝓟389{pathname}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓟387{lhs}.split(𝓛8743{String}));
 let 𝓟390{search}: [miss]𝓛[ty]10051{String} = 𝓛12552{$ArrayAccess}(𝓟387{lhs}.split(𝓛8743{String}));
 let 𝓟391{location} = {pathname: 𝓟389{pathname}.BarBarToken(𝓛8743{String})} as 𝓟[ty]2586{Location};
 if (𝓟390{search})
 {
 𝓟391{location}.search ⟵ 𝓛8743{String}.PlusToken(𝓟390{search});
 }
 if (𝓟388{hash})
 {
 𝓟391{location}.hash ⟵ 𝓛8743{String}.PlusToken(𝓟388{hash});
 }
 return 𝓟385 = 𝓟391{location}
 }
 function 𝓟392{render} (): (𝓟393: [OOV]any)
 {
 let 𝓟394{env} = 𝓟[ty]380{Link}.props.env;
 let 𝓟395{exact} = 𝓟[ty]380{Link}.props.exact;
 let 𝓟396{href} = 𝓟[ty]380{Link}.props.href;
 let 𝓟397{render} = 𝓟[ty]380{Link}.props.render;
 let 𝓟398{other} = 𝓟[ty]380{Link}.props.other;
 let 𝓟399{linkLocation} = 𝓟[ty]380{Link}.getLocation();
 let 𝓟400{navigationLocation} = 𝓟[ty]380{Link}.navigation.getLocation();
 let 𝓟401{active}: [miss]𝓛[ty]8666{Boolean} = 𝓟394{env}.AmpersandAmpersandToken(𝓟399{linkLocation}).AmpersandAmpersandToken((𝓟395{exact} ? 𝓟399{linkLocation}.pathname.EqualsEqualsEqualsToken(𝓟400{navigationLocation}.pathname) : 𝓟400{navigationLocation}.pathname.indexOf(𝓟399{linkLocation}.pathname).EqualsEqualsEqualsToken(𝓛8745{Number}));
 return 𝓟393 = 𝓟397{render}({active: 𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟401{active})),href: (𝓟399{linkLocation} ? 𝓟750{createHref}(𝓟399{linkLocation}) : 𝓟396{href} as 𝓛[ty]10051{String},onFollow: 𝓟[ty]380{Link}.handleFollow})
 }
}
function 𝓟402{CONSTRUCTOR} (): (𝓟[ty]409{AnchorLink})
{
 const 𝓟[ty]409{AnchorLink};
 const 𝓟[ty]409{AnchorLink};
 function 𝓟406{$Lambda46} (𝓟407{event}): (𝓟408: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟407{event}.button.EqualsEqualsEqualsToken(𝓛8745{Number}).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟407{event}.altKey.BarBarToken(𝓟407{event}.ctrlKey).BarBarToken(𝓟407{event}.metaKey).BarBarToken(𝓟407{event}.shiftKey))).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟[ty]409{AnchorLink}.props.target)))
 {
 𝓟[ty]409{AnchorLink}.props.onFollow(𝓟407{event})
 }
 }
 𝓟[ty]409{AnchorLink}.handleClick ⟵ 𝓟406{$Lambda46};
}
class 𝓟[ty]409{AnchorLink} extends 𝓛[ty]33520{Component}{
 𝓟411{handleClick}: [miss]𝓛[ty]8696{Function};
 function 𝓟412{render} (): (𝓟413: [OOV]any)
 {
 let 𝓟414{active} = 𝓟[ty]409{AnchorLink}.props.active;
 let 𝓟415{activeClassName} = 𝓟[ty]409{AnchorLink}.props.activeClassName;
 let 𝓟416{activeStyle} = 𝓟[ty]409{AnchorLink}.props.activeStyle;
 let 𝓟417{className} = 𝓟[ty]409{AnchorLink}.props.className;
 let 𝓟418{disabled} = 𝓟[ty]409{AnchorLink}.props.disabled;
 let 𝓟419{style} = 𝓟[ty]409{AnchorLink}.props.style;
 let 𝓟420{onFollow} = 𝓟[ty]409{AnchorLink}.props.onFollow;
 let 𝓟421{other} = 𝓟[ty]409{AnchorLink}.props.other;
 return 𝓟413 = 𝓛12563{undefined}
 }
}

Module: packages/react-junctions/src/JunctionNavigation

type 𝓟[ty]2604{JunctionNavigationProps} = {history: 𝓛[ty]2{<UNKNOWN>}, root: 𝓟[ty]2616{JunctionTemplate}, style: 𝓛[ty]8642{Object}, followRedirects: 𝓛[ty]8666{Boolean}, waitForInitialContent: 𝓛[ty]8666{Boolean}, addToContext: 𝓛[ty]8666{Boolean}, className: 𝓛[ty]10051{String}, disableScrollHandling: 𝓛[ty]8666{Boolean}, setDocumentTitle: any, render: (any,𝓟[ty]539{BrowserNavigation},𝓟[ty]2586{Location})->𝓛[ty]33220{ReactElement}, announceTitle: any}
let 𝓟423{renderToString}: [OOV]any;
𝓟423{renderToString} ⟵ 𝓛8707{eval}(𝓛8743{String})(𝓛8743{String}).renderToString;
function 𝓟424{$Lambda39} (𝓟425{route}: [OOV]𝓟[ty]2590{JunctionRoute},𝓟426{navigation}: [OOV]𝓟[ty]539{BrowserNavigation},𝓟427{location}: [OOV]𝓟[ty]2586{Location}): (𝓟428: [OOV]any)
{
 return 𝓟428 = 𝓛33460{createElement}(𝓟425{route}.access(𝓛8745{Number}).component,{junction: 𝓟425{route}.access(𝓛8745{Number}),env: {navigation: 𝓟426{navigation},location: 𝓟427{location}}})
}
const 𝓟429{defaultRender}: [miss]𝓛[ty]8696{Function} = 𝓟424{$Lambda39};
let 𝓟430{navigationIdCounter}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
function 𝓟431{CONSTRUCTOR} (𝓟432{props}: [OOV]𝓟[ty]2604{JunctionNavigationProps}): (𝓟[ty]452{JunctionNavigation})
{
 const 𝓟[ty]452{JunctionNavigation};
 const 𝓟[ty]452{JunctionNavigation};
 function 𝓟436{$Lambda40} (): (𝓟437: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟[ty]452{JunctionNavigation}.renderCompleteCallback)
 {
 𝓟[ty]452{JunctionNavigation}.renderCompleteCallback()
 𝓛12560{$Delete}(𝓟[ty]452{JunctionNavigation}.renderCompleteCallback)
 }
 }
 function 𝓟438{$Lambda41} (𝓟439{node}): (𝓟440: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]452{JunctionNavigation}.containerNode ⟵ 𝓟439{node};
 }
 function 𝓟441{$Lambda42} (𝓟442{done}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function})): (𝓟443: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]452{JunctionNavigation}.renderCompleteCallback ⟵ 𝓟442{done};
 𝓟[ty]452{JunctionNavigation}.setState({route: 𝓟[ty]452{JunctionNavigation}.navigation.getRoute(),waitingForInitialContent: 𝓛8744{Boolean}})
 }
 𝓟[ty]452{JunctionNavigation}.setContainer ⟵ 𝓟438{$Lambda41};
 𝓟[ty]452{JunctionNavigation}.handleRenderComplete ⟵ 𝓟436{$Lambda40};
 𝓟[ty]452{JunctionNavigation}.handleRouteChange ⟵ 𝓟441{$Lambda42};
 𝓟[ty]452{JunctionNavigation}(𝓟432{props})
 let 𝓟444{root} = 𝓟432{props}.root;
 let 𝓟445{history} = 𝓟432{props}.history;
 let 𝓟446{followRedirects}: [miss]𝓛[ty]8666{Boolean} = 𝓟432{props}.followRedirects;
 let 𝓟447{announceTitle} = 𝓟432{props}.announceTitle;
 let 𝓟448{setDocumentTitle} = 𝓟432{props}.setDocumentTitle;
 let 𝓟449{waitForInitialContent}: [miss]𝓛[ty]8666{Boolean} = 𝓟432{props}.waitForInitialContent;
 let 𝓟450{disableScrollHandling}: [miss]𝓛[ty]8666{Boolean} = 𝓟432{props}.disableScrollHandling;
 let 𝓟451{addToContext}: [miss]𝓛[ty]8666{Boolean} = 𝓟432{props}.addToContext;
 𝓟[ty]452{JunctionNavigation}.addToContext ⟵ 𝓟451{addToContext};
 𝓟[ty]452{JunctionNavigation}.navigation ⟵ 𝓟508{CONSTRUCTOR}({history: 𝓟445{history},followRedirects: 𝓟446{followRedirects},rootJunctionTemplate: 𝓟444{root},disableScrollHandling: 𝓟450{disableScrollHandling},setDocumentTitle: 𝓟448{setDocumentTitle},announceTitle: 𝓟447{announceTitle}});
 𝓟[ty]452{JunctionNavigation}.navigation.subscribe(𝓟[ty]452{JunctionNavigation}.handleRouteChange,{waitForInitialContent: 𝓟449{waitForInitialContent}})
 if (𝓛12548{ExclamationToken}(𝓟449{waitForInitialContent}).BarBarToken(𝓛12548{ExclamationToken}(𝓟[ty]452{JunctionNavigation}.navigation.isBusy())))
 {
 𝓟[ty]452{JunctionNavigation}.state ⟵ {route: 𝓟[ty]452{JunctionNavigation}.navigation.getRoute()};
 }
 else
 {
 {
 𝓟[ty]452{JunctionNavigation}.serverRenderedHTML ⟵ 𝓛12160{document} as any.getElementById(𝓛8743{String}).innerHTML;
 𝓟[ty]452{JunctionNavigation}.shouldHydrate ⟵ 𝓛8744{Boolean};
 }
 𝓟[ty]452{JunctionNavigation}.state ⟵ {waitingForInitialContent: 𝓛8744{Boolean}};
 }
}
class 𝓟[ty]452{JunctionNavigation} extends 𝓛[ty]33520{Component}{
 𝓟454{setContainer}: [miss]𝓛[ty]8696{Function};
 𝓟455{renderCompleteCallback}: 𝓛[ty]8696{Function};
 𝓟456{handleRouteChange}: [miss]𝓛[ty]8696{Function};
 𝓟457{containerNode}: [OOV]any;
 𝓟458{serverRenderedHTML}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10051{String});
 𝓟459{handleRenderComplete}: [miss]𝓛[ty]8696{Function};
 𝓟460{addToContext}: 𝓛[ty]8666{Boolean};
 𝓟461{navigation}: [OOV]𝓟[ty]539{BrowserNavigation};
 𝓟462{shouldHydrate}: 𝓛[ty]8666{Boolean};
 function 𝓟466{componentDidMount} (): (𝓟467: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]452{JunctionNavigation}.renderChildren()
 }
 function 𝓟468{componentDidUpdate} (): (𝓟469: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]452{JunctionNavigation}.renderChildren()
 }
 function 𝓟463{render} (): (𝓟464: [OOV]any)
 {
 let 𝓟465{string} = (𝓟423{renderToString} ? 𝓟423{renderToString}(𝓟[ty]452{JunctionNavigation}.getElementToRender()) : 𝓟[ty]452{JunctionNavigation}.serverRenderedHTML;
 return 𝓟464 = 𝓛12563{undefined}
 }
 function 𝓟470{getElementToRender} (): (𝓟471: [OOV]any)
 {
 let 𝓟472{render} = 𝓟[ty]452{JunctionNavigation}.props.render.BarBarToken(𝓟429{defaultRender});
 let 𝓟473{content} = 𝓟472{render}(𝓟[ty]452{JunctionNavigation}.state.route,𝓟[ty]452{JunctionNavigation}.navigation,𝓟[ty]452{JunctionNavigation}.navigation.getLocation());
 if (𝓟[ty]452{JunctionNavigation}.addToContext)
 {
 return 𝓟471 = 𝓛12563{undefined}
 }
 else
 {
 return 𝓟471 = 𝓟473{content}
 }
 }
 function 𝓟474{renderChildren} (): (𝓟475: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]452{JunctionNavigation}.state.waitingForInitialContent))
 {
 let 𝓟476{renderer} = (𝓟[ty]452{JunctionNavigation}.shouldHydrate ? 𝓛26621{hydrate} : 𝓛26620{render};
 𝓟476{renderer}(𝓟[ty]452{JunctionNavigation}.getElementToRender(),𝓟[ty]452{JunctionNavigation}.containerNode,𝓟[ty]452{JunctionNavigation}.handleRenderComplete)
 }
 }
}

Module: packages/react-junctions/src/ExitPrompt

type 𝓟[ty]2580{ExitPromptProps} = {env: {navigation: 𝓟[ty]2622{Navigation}}, when: 𝓛[ty]8666{Boolean}, message: any}
const 𝓟478{propTypes}: [miss]𝓛[ty]8642{Object} = {env: 𝓛29759{shape}({navigation: 𝓛29759{shape}({block: 𝓛29736{func}.isRequired})}),when: 𝓛29735{bool},message: 𝓛29750{oneOfType}(𝓛8757{Array}(𝓛29736{func},𝓛29739{string})).isRequired};
const 𝓟479{defaultProps}: [miss]𝓛[ty]8642{Object} = {when: 𝓛8744{Boolean}};
const 𝓟480{contextTypes}: [miss]𝓛[ty]8642{Object} = {navigation: 𝓛29759{shape}({block: 𝓛29736{func}.isRequired}).isRequired};
function 𝓟481{CONSTRUCTOR} (𝓟482{props},𝓟483{context}): (𝓟[ty]487{ExitPrompt})
{
 const 𝓟[ty]487{ExitPrompt};
 const 𝓟[ty]487{ExitPrompt};
 𝓟[ty]487{ExitPrompt}(𝓟482{props},𝓟483{context})
 𝓟[ty]487{ExitPrompt}.navigation ⟵ (𝓟[ty]487{ExitPrompt}.props.env ? 𝓟[ty]487{ExitPrompt}.props.env.navigation : 𝓟483{context}.navigation;
 if (𝓛1{<UNKNOWN>}.NODE_ENV.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]487{ExitPrompt}.navigation))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String}.PlusToken(𝓛8743{String}).PlusToken(𝓛8743{String}))
 }
 }
}
class 𝓟[ty]487{ExitPrompt} extends 𝓛[ty]33520{Component}{
 𝓟489{navigation}: [OOV]𝓟[ty]2622{Navigation};
 𝓟490{unblock}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8696{Function});
 function 𝓟491{enable} (𝓟492{message}): (𝓟493: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟[ty]487{ExitPrompt}.unblock)
 {
 𝓟[ty]487{ExitPrompt}.unblock()
 }
 𝓟[ty]487{ExitPrompt}.unblock ⟵ 𝓟[ty]487{ExitPrompt}.navigation.block(𝓟492{message});
 }
 function 𝓟496{componentDidMount} (): (𝓟497: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟[ty]487{ExitPrompt}.props.when)
 {
 𝓟[ty]487{ExitPrompt}.enable(𝓟[ty]487{ExitPrompt}.props.message)
 }
 }
 function 𝓟498{componentDidUpdate} (𝓟499{nextProps}): (𝓟500: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟499{nextProps}.when)
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]487{ExitPrompt}.props.when).BarBarToken(𝓟[ty]487{ExitPrompt}.props.message.ExclamationEqualsEqualsToken(𝓟499{nextProps}.message)))
 {
 𝓟[ty]487{ExitPrompt}.enable(𝓟499{nextProps}.message)
 }
 }
 else
 {
 𝓟[ty]487{ExitPrompt}.disable()
 }
 }
 function 𝓟494{disable} (): (𝓟495: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟[ty]487{ExitPrompt}.unblock)
 {
 𝓟[ty]487{ExitPrompt}.unblock()
 𝓛12560{$Delete}(𝓟[ty]487{ExitPrompt}.unblock)
 }
 }
 function 𝓟501{componentWillUnmount} (): (𝓟502: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]487{ExitPrompt}.disable()
 }
 function 𝓟503{render} (): (𝓟504: [OOV]any)
 {
 return 𝓟504 = 𝓛12563{undefined}
 }
}

Module: packages/junctions/src/BrowserNavigation

type 𝓟[ty]2596{BrowserNavigationOptions} = {history: 𝓛[ty]2{<UNKNOWN>}, followRedirects: 𝓛[ty]8666{Boolean}, rootJunctionTemplate: any, autoscroll: 𝓛[ty]8666{Boolean}, disableScrollHandling: 𝓛[ty]8666{Boolean}, setDocumentTitle: any, announceTitle: any}
type 𝓟[ty]2560{UnsubscribeCallback} = ()->𝓛[ty]10033{Void}
type 𝓟[ty]2602{ListenCallback} = ((()->{}))->𝓛[ty]10033{Void}
function 𝓟508{CONSTRUCTOR} (𝓟509{options}: [OOV]𝓟[ty]2596{BrowserNavigationOptions}): (𝓟[ty]539{BrowserNavigation})
{
 const 𝓟[ty]539{BrowserNavigation};
 const 𝓟[ty]539{BrowserNavigation};
 function 𝓟513{$Lambda5} (𝓟514{location}): (𝓟515: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟[ty]539{BrowserNavigation}.location.AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟[ty]539{BrowserNavigation}.disableScrollHandling))).AmpersandAmpersandToken(𝓟514{location}.pathname.EqualsEqualsEqualsToken(𝓟[ty]539{BrowserNavigation}.location.pathname)).AmpersandAmpersandToken(𝓟514{location}.hash.EqualsEqualsEqualsToken(𝓟[ty]539{BrowserNavigation}.location.hash)).AmpersandAmpersandToken(𝓟514{location}.search.EqualsEqualsEqualsToken(𝓟[ty]539{BrowserNavigation}.location.search)))
 {
 𝓟[ty]539{BrowserNavigation}.scrollToHash(𝓟514{location}.hash)
 }
 else
 {
 𝓟[ty]539{BrowserNavigation}.router.setLocation(𝓟514{location})
 }
 }
 function 𝓟516{$Lambda6} (𝓟517{previousLocation}: [OOV]any,𝓟518{nextLocation}): (𝓟519: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟517{previousLocation}.EqualsEqualsEqualsToken(𝓟518{nextLocation}))
 {
 }
 if (𝓛12548{ExclamationToken}(𝓟[ty]539{BrowserNavigation}.disableScrollHandling).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟517{previousLocation}).BarBarToken(𝓟517{previousLocation}.hash.ExclamationEqualsEqualsToken(𝓟518{nextLocation}.hash)).BarBarToken(𝓛12548{ExclamationToken}(𝓟518{nextLocation}.hash).AmpersandAmpersandToken(𝓟517{previousLocation}.pathname.ExclamationEqualsEqualsToken(𝓟518{nextLocation}.pathname)))))
 {
 𝓟[ty]539{BrowserNavigation}.location ⟵ 𝓟518{nextLocation};
 if (𝓟517{previousLocation})
 {
 𝓟[ty]539{BrowserNavigation}.scrollToHash(𝓟518{nextLocation}.hash)
 }
 }
 }
 function 𝓟520{$Lambda7} (): (𝓟521: [miss]𝓛[ty]10033{Void})
 {
 let 𝓟522{isBusy}: [miss]𝓛[ty]8666{Boolean} = 𝓟[ty]539{BrowserNavigation}.router.isBusy();
 let 𝓟523{route}: [OOV]𝓟[ty]2590{JunctionRoute} = 𝓟[ty]539{BrowserNavigation}.router.getRoute();
 let 𝓟524{lastSegment}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟523{route}.AmpersandAmpersandToken(𝓟523{route}.access(𝓟523{route}.length.MinusToken(𝓛8745{Number})));
 let 𝓟525{redirectTo}: [OOV]any;
 let 𝓟526{title}: [OOV]any;
 if (𝓛12548{ExclamationToken}(𝓟522{isBusy}).AmpersandAmpersandToken(𝓟524{lastSegment}))
 {
 if (𝓟524{lastSegment}.type.EqualsEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟[ty]539{BrowserNavigation}.history.location.pathname.substr(𝓛12557{MinusToken}(𝓛8745{Number})).ExclamationEqualsEqualsToken(𝓛8743{String})))
 {
 𝓟525{redirectTo} ⟵ 𝓟729{concatLocations}(𝓟[ty]539{BrowserNavigation}.history.location,{pathname: 𝓛8743{String}});
 }
 𝓟526{title} ⟵ 𝓛12563{undefined};
 if (𝓟524{lastSegment}.type.EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 𝓟525{redirectTo} ⟵ 𝓟524{lastSegment}.to;
 }
 else
 {
 if (𝓟524{lastSegment}.type.EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 if (𝓟524{lastSegment}.contentStatus.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 𝓟[ty]539{BrowserNavigation}.waitingForInitialContent ⟵ 𝓛8744{Boolean};
 }
 𝓟526{title} ⟵ 𝓟524{lastSegment}.title;
 }
 else
 {
 if (𝓟524{lastSegment}.status.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 𝓟[ty]539{BrowserNavigation}.waitingForInitialContent ⟵ 𝓛8744{Boolean};
 }
 }
 }
 }
 if (𝓟[ty]539{BrowserNavigation}.followRedirects.AmpersandAmpersandToken(𝓟525{redirectTo}))
 {
 𝓟[ty]539{BrowserNavigation}.replaceLocation(𝓟525{redirectTo})
 }
 if (𝓟526{title}.ExclamationEqualsEqualsToken(𝓛12563{undefined}))
 {
 if (𝓟[ty]539{BrowserNavigation}.announceTitle)
 {
 𝓟602{announce}(𝓟[ty]539{BrowserNavigation}.announceTitle(𝓟526{title}))
 }
 if (𝓟[ty]539{BrowserNavigation}.setDocumentTitle)
 {
 𝓛12160{document}.title ⟵ 𝓟[ty]539{BrowserNavigation}.setDocumentTitle(𝓟526{title});
 }
 }
 let 𝓟527{waitCount}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 function 𝓟528{$Lambda8} (): (𝓟529: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12556{MinusMinusToken}(𝓟527{waitCount}).LessThanEqualsToken(𝓛8745{Number}))
 {
 if (𝓛12548{ExclamationToken}(𝓟522{isBusy}))
 {
 𝓟[ty]539{BrowserNavigation}.handleLocationChange(𝓟[ty]539{BrowserNavigation}.location,𝓟[ty]539{BrowserNavigation}.history.location)
 }
 }
 }
 let 𝓟530{decreaseWaitCount}: [miss]𝓛[ty]8696{Function} = 𝓟528{$Lambda8};
 {
 let 𝓟531{subscriber}: [miss]𝓛[ty]8642{Object} = 𝓛12552{$ArrayAccess}(𝓟[ty]539{BrowserNavigation}.subscribers);
 while (𝓛8744{Boolean})
 {
 if (𝓛12548{ExclamationToken}(𝓟522{isBusy}).BarBarToken(𝓛12548{ExclamationToken}(𝓟531{subscriber}.waitForInitialContent)).BarBarToken(𝓛12548{ExclamationToken}(𝓟[ty]539{BrowserNavigation}.waitingForInitialContent)))
 {
 if (𝓟531{subscriber}.callback.length.GreaterThanToken(𝓛8745{Number}))
 {
 𝓛12546{POST_PlusPlusToken}(𝓟527{waitCount})
 𝓟531{subscriber}.callback(𝓟530{decreaseWaitCount} as any)
 }
 else
 {
 𝓟531{subscriber}.callback()
 }
 }
 }
 }
 if (𝓟527{waitCount}.EqualsEqualsEqualsToken(𝓛8745{Number}))
 {
 𝓟530{decreaseWaitCount}()
 }
 }
 𝓟[ty]539{BrowserNavigation}.handleHistoryChange ⟵ 𝓟513{$Lambda5};
 𝓟[ty]539{BrowserNavigation}.handleLocationChange ⟵ 𝓟516{$Lambda6};
 𝓟[ty]539{BrowserNavigation}.handleRouteChange ⟵ 𝓟520{$Lambda7};
 if (𝓟509{options}.announceTitle.ExclamationEqualsEqualsToken(𝓛8744{Boolean}))
 {
 function 𝓟532{$Lambda2} (𝓟533{x}): (𝓟534: [miss]𝓛[ty]10051{String})
 {
 return 𝓟534 = 𝓟533{x}.BarBarToken(𝓛8743{String})
 }
 𝓟[ty]539{BrowserNavigation}.announceTitle ⟵ (𝓛12550{$TypeOf}(𝓟509{options}.announceTitle).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟509{options}.announceTitle : 𝓟532{$Lambda2};
 𝓟610{createAnnouncerDiv}()
 }
 if (𝓟509{options}.setDocumentTitle.ExclamationEqualsEqualsToken(𝓛8744{Boolean}))
 {
 function 𝓟535{$Lambda3} (𝓟536{x}): (𝓟537: [miss]𝓛[ty]10051{String})
 {
 return 𝓟537 = 𝓟536{x}.BarBarToken(𝓛8743{String})
 }
 𝓟[ty]539{BrowserNavigation}.setDocumentTitle ⟵ (𝓛12550{$TypeOf}(𝓟509{options}.setDocumentTitle).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟509{options}.setDocumentTitle : 𝓟535{$Lambda3};
 }
 𝓟[ty]539{BrowserNavigation}.autoscroll ⟵ (𝓟509{options}.autoscroll.ExclamationEqualsEqualsToken(𝓛12563{undefined}) ? 𝓟509{options}.autoscroll : 𝓛8744{Boolean};
 𝓟[ty]539{BrowserNavigation}.followRedirects ⟵ (𝓟509{options}.followRedirects.ExclamationEqualsEqualsToken(𝓛12563{undefined}) ? 𝓟509{options}.followRedirects : 𝓛8744{Boolean};
 𝓟[ty]539{BrowserNavigation}.subscribers ⟵ 𝓛8757{Array}();
 𝓟[ty]539{BrowserNavigation}.waitingForInitialContent ⟵ 𝓛8744{Boolean};
 𝓟[ty]539{BrowserNavigation}.disableScrollHandling ⟵ 𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟509{options}.disableScrollHandling));
 𝓟[ty]539{BrowserNavigation}.history ⟵ 𝓟509{options}.history.BarBarToken(𝓟773{createBrowserHistory}());
 𝓟[ty]539{BrowserNavigation}.history.listen(𝓟[ty]539{BrowserNavigation}.handleHistoryChange)
 let 𝓟538{routerConfig}: [OOV]𝓟[ty]2574{RouterConfig} = 𝓟83{createRouterConfig}({rootJunctionTemplate: 𝓟509{options}.rootJunctionTemplate});
 𝓟[ty]539{BrowserNavigation}.router ⟵ 𝓟284{CONSTRUCTOR}(𝓟538{routerConfig});
 𝓟[ty]539{BrowserNavigation}.router.subscribe(𝓟[ty]539{BrowserNavigation}.handleRouteChange)
 𝓛8741{Object}.assign(𝓟[ty]539{BrowserNavigation},𝓟185{createContentHelpers}(𝓟538{routerConfig}))
 𝓟[ty]539{BrowserNavigation}.router.setLocation(𝓟[ty]539{BrowserNavigation}.history.location)
}
class 𝓟[ty]539{BrowserNavigation} extends 𝓟[ty]2622{Navigation}{
 𝓟541{handleLocationChange}: [miss]𝓛[ty]8696{Function};
 𝓟542{location}: [OOV]any;
 𝓟543{getPages}: [OOV]any;
 𝓟544{history}: [OOV]𝓛[ty]2{<UNKNOWN>};
 𝓟545{subscribers}: 𝓛[ty]8670{Array};
 𝓟546{getPageMap}: [OOV]any;
 𝓟547{getRouteSegment}: [OOV]any;
 𝓟548{followRedirects}: 𝓛[ty]8666{Boolean};
 𝓟549{handleRouteChange}: [miss]𝓛[ty]8696{Function};
 𝓟550{autoscroll}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]8666{Boolean});
 𝓟551{handleHistoryChange}: [miss]𝓛[ty]8696{Function};
 𝓟552{disableScrollHandling}: 𝓛[ty]8666{Boolean};
 𝓟553{setDocumentTitle}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function});
 𝓟554{waitingForInitialContent}: 𝓛[ty]8666{Boolean};
 𝓟555{router}: [OOV]𝓟[ty]292{Router};
 𝓟556{announceTitle}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8696{Function});
 function 𝓟568{isBusy} (): (𝓟569: 𝓛[ty]8666{Boolean})
 {
 return 𝓟569 = 𝓟[ty]539{BrowserNavigation}.router.isBusy()
 }
 function 𝓟557{subscribe} (𝓟558{onChange}: [OOV]𝓟[ty]2602{ListenCallback},𝓟559{options}: 𝓛[ty]8642{Object}): (𝓟560: [OOV]𝓟[ty]2560{UnsubscribeCallback})
 {
 let 𝓟561{subscriber}: [miss]𝓛[ty]8642{Object} = {callback: 𝓟558{onChange},waitForInitialContent: 𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟559{options}.waitForInitialContent))};
 𝓟[ty]539{BrowserNavigation}.subscribers.push(𝓟561{subscriber})
 function 𝓟562{$Lambda4} (): (𝓟563: [miss]𝓛[ty]10033{Void})
 {
 let 𝓟564{index}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]539{BrowserNavigation}.subscribers.indexOf(𝓟561{subscriber});
 if (𝓟564{index}.ExclamationEqualsEqualsToken(𝓛12557{MinusToken}(𝓛8745{Number})))
 {
 𝓟[ty]539{BrowserNavigation}.subscribers.splice(𝓟564{index},𝓛8745{Number})
 }
 }
 return 𝓟560 = 𝓟562{$Lambda4}
 }
 function 𝓟592{pushLocation} (𝓟593{location}: [OOV]any,𝓟594{state}: [OOV]any): (𝓟595: 𝓛[ty]10033{Void})
 {
 𝓟[ty]539{BrowserNavigation}.history.push(𝓟593{location},𝓟594{state})
 }
 function 𝓟596{scrollToHash} (𝓟597{hash}): (𝓟598: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟597{hash})
 {
 let 𝓟599{id}: [miss]𝓛[ty]10921{HTMLElement} = 𝓛12160{document}.getElementById(𝓟597{hash}.slice(𝓛8745{Number}));
 if (𝓟599{id})
 {
 𝓟599{id}.scrollIntoView({behavior: 𝓛8743{String},block: 𝓛8743{String}})
 𝓟599{id}.focus()
 }
 else
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 }
 else
 {
 𝓛12233{window}.scroll({top: 𝓛8745{Number},left: 𝓛8745{Number},behavior: 𝓛8743{String}})
 }
 }
 function 𝓟565{block} (𝓟566{message}: 𝓛[ty]10051{String}): (𝓟567: [OOV]𝓛[ty]2{<UNKNOWN>})
 {
 return 𝓟567 = 𝓟[ty]539{BrowserNavigation}.history.block(𝓟566{message})
 }
 function 𝓟572{getLocation} (): (𝓟573: [OOV]𝓟[ty]2586{Location})
 {
 return 𝓟573 = 𝓟[ty]539{BrowserNavigation}.history.location
 }
 function 𝓟581{replaceLocation} (𝓟582{location}: [OOV]any,𝓟583{state}): (𝓟584: 𝓛[ty]10033{Void})
 {
 𝓟[ty]539{BrowserNavigation}.history.replace(𝓟582{location},𝓟583{state})
 }
 function 𝓟570{getRoute} (): (𝓟571: [OOV]any)
 {
 return 𝓟571 = 𝓟[ty]539{BrowserNavigation}.router.getRoute()
 }
}
let 𝓟600{announcerId}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
let 𝓟601{announcerTimeout};
function 𝓟602{announce} (𝓟603{message}: 𝓛[ty]10051{String},𝓟604{manner}): (𝓟605: [miss]𝓛[ty]10033{Void})
{
 let 𝓟606{announcer}: [miss]𝓛[ty]10921{HTMLElement} = 𝓛12160{document}.getElementById(𝓟600{announcerId});
 𝓟604{manner} ⟵ 𝓟604{manner}.BarBarToken(𝓛8743{String});
 if (𝓟606{announcer})
 {
 𝓟606{announcer}.setAttribute(𝓛8743{String},𝓛8743{String})
 𝓟606{announcer}.setAttribute(𝓛8743{String},𝓟604{manner})
 𝓟606{announcer}.innerHTML ⟵ 𝓟603{message};
 𝓛12465{clearTimeout}(𝓟601{announcerTimeout})
 function 𝓟607{$Lambda9} (): (𝓟608: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟606{announcer})
 {
 𝓟606{announcer}.innerHTML ⟵ 𝓛8743{String};
 }
 𝓟601{announcerTimeout} ⟵ 𝓛12563{undefined};
 }
 𝓟601{announcerTimeout} ⟵ 𝓛12490{setTimeout}(𝓟607{$Lambda9},𝓛8745{Number});
 }
}
let 𝓟609{announcerDiv};
function 𝓟610{createAnnouncerDiv} (): (𝓟611: [OOV]any)
{
 if (𝓟609{announcerDiv})
 {
 return 𝓟611 = 𝓟609{announcerDiv}
 }
 𝓟609{announcerDiv} ⟵ 𝓛12160{document}.createElement(𝓛8743{String});
 𝓟609{announcerDiv}.id ⟵ 𝓟600{announcerId};
 𝓟609{announcerDiv}.setAttribute(𝓛8743{String},𝓛8743{String})
 let 𝓟612{style} = 𝓟609{announcerDiv}.style;
 𝓟612{style}.position ⟵ 𝓛8743{String};
 𝓟612{style}.left ⟵ 𝓛8743{String};
 𝓟612{style}.top ⟵ 𝓛8743{String};
 𝓟612{style}.width ⟵ 𝓛8743{String};
 𝓟612{style}.height ⟵ 𝓛8743{String};
 𝓟612{style}.overflow ⟵ 𝓛8743{String};
 𝓛12160{document}.body.appendChild(𝓟609{announcerDiv})
}

Module: packages/junctions/src/AsyncObjectContainer

type 𝓟[ty]2599{AsyncObjectContainer} = {getter: (𝓟[ty]2574{RouterConfig})->any, error: any, status: any, type: 𝓛[ty]10051{String}, promise: 𝓛[ty]8654{Promise}, value: any}

Module: packages/junctions/src/Route

type 𝓟[ty]2597{Page} extends 𝓟[ty]2617{RouteSegmentBase} = {contentError: any, contentStatus: any, meta: any, content: any, title: 𝓛[ty]10051{String}, component: any}
type 𝓟[ty]2587{Route} extends 𝓛[ty]8670{Array} = {0: any, access: (𝓛[ty]8655{Number})->𝓛[ty]0{ANY}}
type 𝓟[ty]2585{Redirect} extends 𝓟[ty]2617{RouteSegmentBase} = {to: 𝓟[ty]2586{Location}, meta: any, component: any}
type 𝓟[ty]2613{RedirectRoute} extends 𝓟[ty]2587{Route} = {0: 𝓟[ty]2585{Redirect}}
type 𝓛[ty]0{ANY} = any
type 𝓛[ty]0{ANY} = any
type 𝓛[ty]0{ANY} = any
type 𝓟[ty]2618{PageRoute} extends 𝓟[ty]2587{Route} = {0: 𝓟[ty]2597{Page}}
type 𝓟[ty]2590{JunctionRoute} extends 𝓟[ty]2587{Route} = {0: 𝓟[ty]2609{Junction}}
type 𝓟[ty]2617{RouteSegmentBase} = {location: 𝓟[ty]2586{Location}, url: 𝓛[ty]10051{String}, params: {access: (𝓛[ty]10051{String})->any}, template: 𝓛[ty]0{ANY}, type: any}
type 𝓟[ty]2583{JunctionDescendentSegments} extends 𝓛[ty]8670{Array} = {0: 𝓛[ty]0{ANY}, access: (𝓛[ty]8655{Number})->𝓛[ty]0{ANY}}
type 𝓟[ty]2609{Junction} extends 𝓟[ty]2617{RouteSegmentBase} = {children: any, activeRoute: 𝓟[ty]2583{JunctionDescendentSegments}, meta: any, activePattern: any, activeChild: 𝓛[ty]0{ANY}, status: any, component: any}

Module: packages/junctions/src/Navigation

type 𝓟[ty]2622{Navigation} = {getPages: any, pushLocation: (𝓛[ty]10051{String},any)->𝓛[ty]10033{Void}, block: (𝓛[ty]10051{String})->()->𝓛[ty]10033{Void}, getLocation: ()->𝓟[ty]2586{Location}, replaceLocation: (𝓛[ty]10051{String},any)->𝓛[ty]10033{Void}}

Module: packages/junctions/src/index

Module: packages/junctions/src/Template

type 𝓟[ty]2570{MatcherOptions} = {parentLocationPart: 𝓟[ty]2586{Location}, onChange: ()->𝓛[ty]10033{Void}, routerConfig: 𝓟[ty]2574{RouterConfig}, matchableLocationPart: 𝓟[ty]2586{Location}, shouldFetchContent: 𝓛[ty]8666{Boolean}, mountedPattern: 𝓟[ty]2569{MountedPattern}}
type 𝓟[ty]2578{TemplateBase} = {type: 𝓛[ty]10051{String}, params: 𝓛[ty]8670{Array}, CONSTRUCTOR: (𝓟[ty]2570{MatcherOptions})->any, prototype: any}
type 𝓛[ty]0{ANY} = any
type 𝓟[ty]613{AsyncObjectContainer} = 𝓟[ty]2599{AsyncObjectContainer}
function 𝓟631{CONSTRUCTOR} (𝓟632{options}: [OOV]𝓟[ty]2570{MatcherOptions}): (𝓟[ty]641{Matcher})
{
 const 𝓟[ty]641{Matcher};
 const 𝓟[ty]641{Matcher};
 function 𝓟636{$Lambda34} (): (𝓟637: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]641{Matcher}.unmounted))
 {
 𝓟[ty]641{Matcher}.onChange()
 }
 }
 𝓟[ty]641{Matcher}.handleChange ⟵ 𝓟636{$Lambda34};
 let 𝓟638{parentLocationPart}: [OOV]𝓟[ty]2586{Location} = 𝓟632{options}.parentLocationPart;
 let 𝓟639{matchableLocationPart}: [OOV]𝓟[ty]2586{Location} = 𝓟632{options}.matchableLocationPart;
 let 𝓟640{patternWithoutSearchParams}: [OOV]𝓟[ty]2569{MountedPattern} = 𝓟632{options}.mountedPattern;
 𝓟[ty]641{Matcher}.mountedPattern ⟵ 𝓟49{addParamsToMountedPattern}(𝓟640{patternWithoutSearchParams},𝓟[ty]641{Matcher}.constructor.params);
 𝓟[ty]641{Matcher}.waitingForWatch ⟵ 𝓛8744{Boolean};
 𝓟[ty]641{Matcher}.unmounted ⟵ 𝓛8744{Boolean};
 𝓟[ty]641{Matcher}.onChange ⟵ 𝓟632{options}.onChange;
 𝓟[ty]641{Matcher}.routerConfig ⟵ 𝓟632{options}.routerConfig;
 𝓟[ty]641{Matcher}.shouldFetchContent ⟵ 𝓟632{options}.shouldFetchContent;
 𝓟[ty]641{Matcher}.match ⟵ 𝓟64{matchMountedPatternAgainstLocation}(𝓟[ty]641{Matcher}.mountedPattern,𝓟639{matchableLocationPart});
 𝓟[ty]641{Matcher}.segmentLocation ⟵ 𝓟729{concatLocations}(𝓟638{parentLocationPart},(𝓟[ty]641{Matcher}.match ? 𝓟[ty]641{Matcher}.match.matchedLocation : 𝓟639{matchableLocationPart});
 𝓟[ty]641{Matcher}.matchableLocationPart ⟵ 𝓟639{matchableLocationPart};
}
class 𝓟[ty]641{Matcher}{
 𝓟643{$ComputedPropertyName}: [OOV]𝓛[ty]0{ANY};
 𝓟644{onChange}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8696{Function});
 𝓟645{routerConfig}: [OOV]𝓟[ty]2574{RouterConfig};
 𝓟646{segmentLocation}: [OOV]𝓟[ty]2586{Location};
 𝓟647{match}: [OOV]𝓟[ty]2563{PatternMatch};
 𝓟648{matchableLocationPart}: [OOV]𝓟[ty]2586{Location};
 𝓟649{handleChange}: [miss]𝓛[ty]8696{Function};
 𝓟650{unmounted}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8666{Boolean});
 𝓟651{shouldFetchContent}: 𝓛[ty]8666{Boolean};
 𝓟652{mountedPattern}: [OOV]𝓟[ty]2569{MountedPattern};
 𝓟653{waitingForWatch}: 𝓛[ty]8666{Boolean};
 function 𝓟656{isBusy} (): (𝓟657: 𝓛[ty]8666{Boolean})
 {
 return 𝓟657 = 𝓛12548{ExclamationToken}(𝓛12548{ExclamationToken}(𝓟[ty]641{Matcher}.waitingForWatch))
 }
 function 𝓟654{willUnmount} (): (𝓟655: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]641{Matcher}.unmounted ⟵ 𝓛8744{Boolean};
 }
 function 𝓟664{watchAsync} (𝓟665{async}: [OOV]any,𝓟666{event}: 𝓛[ty]8642{Object},𝓟667{callback}: 𝓛[ty]8696{Function}): (𝓟668: 𝓛[ty]10033{Void})
 {
 if (𝓛12548{ExclamationToken}(𝓟665{async}.status).BarBarToken(𝓟665{async}.status.ExclamationEqualsEqualsToken(𝓛8743{String})))
 {
 let 𝓟669{result} = 𝓟665{async}.getter(𝓟[ty]641{Matcher}.routerConfig);
 if (𝓟669{result}.AmpersandAmpersandToken(𝓟669{result}.then))
 {
 𝓟665{async}.promise ⟵ 𝓟669{result};
 𝓟665{async}.status ⟵ 𝓛8743{String};
 }
 else
 {
 𝓟665{async}.value ⟵ 𝓟669{result};
 𝓟665{async}.status ⟵ 𝓛8743{String};
 }
 }
 if (𝓟665{async}.status.EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 𝓟667{callback}(𝓛8743{String},𝓟665{async}.value)
 }
 if (𝓟665{async}.status.EqualsEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟665{async}.promise))
 {
 𝓟667{callback}(𝓛8743{String})
 𝓟[ty]641{Matcher}.waitingForWatch ⟵ 𝓛8744{Boolean};
 𝓟[ty]641{Matcher}.routerConfig.onEvent({type: 𝓟666{event}.access(𝓛8743{String}).PlusToken(𝓛8743{String})} as any)
 function 𝓟670{$Lambda35} (𝓟671{value}): (𝓟672: [miss]𝓛[ty]10033{Void})
 {
 𝓟665{async}.status ⟵ 𝓛8743{String};
 𝓟665{async}.value ⟵ 𝓟671{value};
 𝓟667{callback}(𝓟665{async}.status,𝓟665{async}.value)
 }
 function 𝓟673{$Lambda36} (𝓟674{error}): (𝓟675: [miss]𝓛[ty]10033{Void})
 {
 𝓟665{async}.status ⟵ 𝓛8743{String};
 𝓟665{async}.promise ⟵ 𝓛12563{undefined};
 𝓟665{async}.error ⟵ 𝓟674{error};
 𝓛1{<UNKNOWN>}(𝓟674{error})
 𝓟667{callback}(𝓛8743{String},𝓛12563{undefined},𝓟674{error})
 }
 function 𝓟676{$Lambda37} (): (𝓟677: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]641{Matcher}.waitingForWatch ⟵ 𝓛8744{Boolean};
 𝓟[ty]641{Matcher}.routerConfig.onEvent({type: 𝓟666{event}.access(𝓛8743{String}).PlusToken(𝓛8743{String})} as any)
 𝓟[ty]641{Matcher}.handleChange()
 }
 𝓟665{async}.promise.then(𝓟670{$Lambda35},𝓟673{$Lambda36}).then(𝓟676{$Lambda37})
 }
 }
 function 𝓟658{getRoute} (): (𝓟659: [OOV]any)
 {
 }
 function 𝓟660{createSegment} (𝓟661{type}: [OOV]any,𝓟662{details}: [OOV]any): (𝓟663: [OOV]any)
 {
 return 𝓟663 = 𝓛8741{Object}.assign({location: 𝓟[ty]641{Matcher}.segmentLocation,url: 𝓟[ty]641{Matcher}.segmentLocation.pathname.PlusToken(𝓟[ty]641{Matcher}.segmentLocation.search.BarBarToken(𝓛8743{String})),params: 𝓟[ty]641{Matcher}.match.AmpersandAmpersandToken(𝓟[ty]641{Matcher}.match.params).BarBarToken({}),meta: 𝓛12563{undefined} as any,template: 𝓟[ty]641{Matcher}.constructor,type: 𝓟661{type},component: 𝓛12563{undefined} as any},𝓟662{details})
 }
}

Module: packages/react-junctions/src/JunctionActiveChild

type 𝓟[ty]2592{JunctionActiveChildProps} = {busyElement: 𝓛[ty]33220{ReactElement}, notFoundElement: 𝓛[ty]33220{ReactElement}, errorElement: 𝓛[ty]33220{ReactElement}, render: (𝓟[ty]2564{JunctionActiveChildRendererProps})->𝓛[ty]33220{ReactElement}, junction: 𝓟[ty]2609{Junction}, env: any}
type 𝓟[ty]2564{JunctionActiveChildRendererProps} = {Component: 𝓛[ty]33387{ComponentType}, child: any, env: any}
function 𝓟680{$Lambda38} (𝓟681{_}: [OOV]𝓟[ty]2564{JunctionActiveChildRendererProps}): (𝓟682: [OOV]any)
{
}
const 𝓟683{defaultJunctionActiveChildRenderer}: [miss]𝓛[ty]8696{Function} = 𝓟680{$Lambda38};
function 𝓟684{JunctionActiveChild} (𝓟685{_}: [OOV]𝓟[ty]2592{JunctionActiveChildProps}): (𝓟686: [OOV]any)
{
}

Module: packages/junctions/notes/JunctionWithHiddenChildren

type 𝓟[ty]2589{JunctionState} = {children: 𝓟[ty]2589{JunctionState}, contentStatus: 𝓛[ty]0{ANY}, pathTemplate: 𝓛[ty]10051{String}, childrenStatus: 𝓛[ty]0{ANY}, meta: any, content: any, hiddenChildrenStatus: any, locate: 𝓟[ty]2584{LocateFn}, hiddenChildren: any}
type 𝓟[ty]2584{LocateFn} = (𝓛[ty]0{ANY})->𝓛[ty]11245{Location}
type 𝓟[ty]2588{GetterOptions} = {context: any, params: {access: (𝓛[ty]10051{String})->any}, locate: 𝓟[ty]2584{LocateFn}, junction: 𝓟[ty]2623{JunctionFn}}
type 𝓟[ty]2562{JunctionChildren} = {access: (𝓛[ty]10051{String})->any}
type 𝓛[ty]0{ANY} = any
type 𝓛[ty]0{ANY} = any
type 𝓟[ty]2623{JunctionFn} = (𝓛[ty]11245{Location})->any
type 𝓛[ty]0{ANY} = any
type 𝓟[ty]2559{Junction} = {children: any, getChildContext: (𝓟[ty]2588{GetterOptions})->any, params: any, meta: any, getRedirectLocation: (𝓟[ty]2588{GetterOptions})->any, getContent: (𝓟[ty]2588{GetterOptions})->any, hiddenChildren: any}
type 𝓛[ty]0{ANY} = any
type 𝓟[ty]2566{JunctionHiddenChildren} = {access: (𝓛[ty]10051{String})->𝓟[ty]2562{JunctionChildren}}

Module: packages/react-junctions/src/NavigationProvider

const 𝓟698{childContextTypes}: [miss]𝓛[ty]8642{Object} = {navigation: 𝓛29738{object}};
function 𝓟699{CONSTRUCTOR} (): (𝓟[ty]703{NavigationProvider})
{
 const 𝓟[ty]703{NavigationProvider};
 const 𝓟[ty]703{NavigationProvider};
}
class 𝓟[ty]703{NavigationProvider} extends 𝓛[ty]33520{Component}{
 function 𝓟705{getChildContext} (): (𝓟706: [miss]𝓛[ty]8642{Object})
 {
 return 𝓟706 = {navigation: 𝓟[ty]703{NavigationProvider}.props.navigation}
 }
 function 𝓟707{render} (): (𝓟708: [OOV]any)
 {
 return 𝓟708 = 𝓟[ty]703{NavigationProvider}.props.children
 }
}

Module: packages/junctions/src/RedirectTemplate

type 𝓟[ty]2576{RedirectTemplate} extends 𝓟[ty]2578{TemplateBase} = {templateType: 𝓛[ty]10051{String}, to: any, meta: any, component: any, CONSTRUCTOR: (𝓟[ty]2570{MatcherOptions})->𝓟[ty]716{RedirectMatcher}}
const 𝓟710{type}: 𝓛[ty]10051{String} = 𝓛8743{String};
const 𝓟711{templateType}: 𝓛[ty]10051{String} = 𝓛8743{String};
function 𝓟712{CONSTRUCTOR} (): (𝓟[ty]716{RedirectMatcher})
{
 const 𝓟[ty]716{RedirectMatcher};
 const 𝓟[ty]716{RedirectMatcher};
}
class 𝓟[ty]716{RedirectMatcher} extends 𝓟[ty]641{Matcher}{
 𝓟718{$ComputedPropertyName}: [OOV]𝓟[ty]2576{RedirectTemplate};
 function 𝓟719{getRoute} (): (𝓟720: [OOV]any)
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]716{RedirectMatcher}.match).BarBarToken(𝓟[ty]716{RedirectMatcher}.match.remainingLocation.AmpersandAmpersandToken(𝓟[ty]716{RedirectMatcher}.match.remainingLocation.pathname.ExclamationEqualsEqualsToken(𝓛8743{String}))))
 {
 }
 let 𝓟721{to}: [OOV]𝓟[ty]2586{Location} = (𝓛12550{$TypeOf}(𝓟[ty]716{RedirectMatcher}.constructor.to).EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟[ty]716{RedirectMatcher}.constructor.to(𝓟[ty]716{RedirectMatcher}.segmentLocation) : 𝓟[ty]716{RedirectMatcher}.constructor.to;
 return 𝓟720 = 𝓛8757{Array}(𝓟[ty]716{RedirectMatcher}.createSegment(𝓛8743{String},{to: 𝓟721{to}}))
 }
}
function 𝓟722{createRedirectTemplate} (𝓟723{to}: [OOV]any,𝓟724{meta}: [OOV]any): (𝓟725: [OOV]𝓟[ty]2576{RedirectTemplate})
{
 let 𝓟726{toLocation} = (𝓛12550{$TypeOf}(𝓟723{to}).EqualsEqualsEqualsToken(𝓛8743{String}) ? {pathname: 𝓟723{to}} : 𝓟723{to};
 return 𝓟725 = 𝓛12563{undefined}
}

Module: packages/react-junctions/src/index

Module: packages/junctions/src/Location

type 𝓟[ty]2562{JunctionChildren} = {access: (𝓛[ty]10051{String})->any}
type 𝓟[ty]2586{Location} = {pathname: 𝓛[ty]10051{String}, search: 𝓛[ty]10051{String}, hash: 𝓛[ty]10051{String}, state: 𝓛[ty]8642{Object}}
function 𝓟729{concatLocations} (𝓟730{firstLocation}: [OOV]any,𝓟731{locations}: 𝓛[ty]8670{Array}): (𝓟732: [OOV]𝓟[ty]2586{Location})
{
 let 𝓟733{result}: [OOV]𝓟[ty]2586{Location} = (𝓛12550{$TypeOf}(𝓟730{firstLocation}).EqualsEqualsEqualsToken(𝓛8743{String}) ? {pathname: 𝓟730{firstLocation}} as 𝓟[ty]2586{Location} : 𝓟730{firstLocation};
 {
 let 𝓟734{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓟734{i}.FirstBinaryOperator(𝓟731{locations}.length))
 {
 {
 let 𝓟735{location} = 𝓟731{locations}.access(𝓟734{i});
 if (𝓛12550{$TypeOf}(𝓟735{location}).EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 𝓟735{location} ⟵ 𝓟737{parseLocationString}(𝓟735{location});
 }
 𝓟733{result} ⟵ {pathname: 𝓟741{joinPaths}(𝓟733{result}.pathname,𝓟735{location}.pathname),search: 𝓟745{joinQueryStrings}(𝓟733{result}.search,𝓟735{location}.search,𝓛8743{String}),hash: 𝓟745{joinQueryStrings}(𝓟733{result}.hash,𝓟735{location}.hash,𝓛8743{String}),state: (𝓟733{result}.state.BarBarToken(𝓟735{location}.state) ? 𝓛8741{Object}.assign({},𝓟733{result}.state,𝓟735{location}.state) : 𝓛12563{undefined}};
 }
 𝓛12546{POST_PlusPlusToken}(𝓟734{i})
 }
 }
 return 𝓟732 = 𝓟733{result}
}
const 𝓟736{parsePattern}: [miss]𝓛[ty]8662{RegExp} = 𝓛8748{RegExp};
function 𝓟737{parseLocationString} (𝓟738{locationString}: 𝓛[ty]10051{String}): (𝓟739: [OOV]𝓟[ty]2586{Location})
{
 let 𝓟740{matches}: [OOV]𝓛[ty]8682{RegExpExecArray} = 𝓟736{parsePattern}.exec(𝓟738{locationString});
 if (𝓛12548{ExclamationToken}(𝓟740{matches}))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 return 𝓟739 = {pathname: 𝓟740{matches}.access(𝓛8745{Number}),search: 𝓟740{matches}.access(𝓛8745{Number}),hash: 𝓟740{matches}.access(𝓛8745{Number})}
}
function 𝓟741{joinPaths} (𝓟742{a},𝓟743{b}): (𝓟744: [OOV]any)
{
 if (𝓛12548{ExclamationToken}(𝓟743{b}))
 {
 return 𝓟744 = 𝓟742{a}
 }
 if (𝓟742{a}.access(𝓟742{a}.length.MinusToken(𝓛8745{Number})).EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 𝓟742{a} ⟵ 𝓟742{a}.substr(𝓛8745{Number},𝓟742{a}.length.MinusToken(𝓛8745{Number}));
 }
 if (𝓟743{b}.access(𝓛8745{Number}).EqualsEqualsEqualsToken(𝓛8743{String}))
 {
 𝓟743{b} ⟵ 𝓟743{b}.substr(𝓛8745{Number});
 }
 return 𝓟744 = 𝓟742{a}.PlusToken(𝓛8743{String}).PlusToken(𝓟743{b})
}
function 𝓟745{joinQueryStrings} (𝓟746{left},𝓟747{right},𝓟748{leadingCharacter}): (𝓟749: 𝓛[ty]10051{String})
{
 if (𝓛12548{ExclamationToken}(𝓟746{left}).BarBarToken(𝓟746{left}.access(𝓛8745{Number}).ExclamationEqualsEqualsToken(𝓟748{leadingCharacter})))
 {
 return 𝓟749 = 𝓟747{right}
 }
 if (𝓛12548{ExclamationToken}(𝓟747{right}).BarBarToken(𝓟747{right}.access(𝓛8745{Number}).ExclamationEqualsEqualsToken(𝓟748{leadingCharacter})))
 {
 return 𝓟749 = 𝓟746{left}
 }
 return 𝓟749 = 𝓟748{leadingCharacter}.PlusToken(𝓟746{left}.slice(𝓛8745{Number})).PlusToken(𝓛8743{String}).PlusToken(𝓟747{right}.slice(𝓛8745{Number}))
}
function 𝓟750{createHref} (𝓟751{location}: [OOV]𝓟[ty]2586{Location}): (𝓟752: 𝓛[ty]10051{String})
{
 return 𝓟752 = 𝓟751{location}.pathname.PlusToken(𝓟751{location}.search.BarBarToken(𝓛8743{String})).PlusToken(𝓟751{location}.hash.BarBarToken(𝓛8743{String}))
}
function 𝓟753{parseQuery} (𝓟754{queryString}: 𝓛[ty]10051{String},𝓟755{leadingCharacter}): (𝓟756: [OOV]𝓟[ty]2562{JunctionChildren})
{
 if (𝓛12548{ExclamationToken}(𝓟754{queryString}).BarBarToken(𝓟754{queryString}.access(𝓛8745{Number}).ExclamationEqualsToken(𝓟755{leadingCharacter})))
 {
 return 𝓟756 = {}
 }
 let 𝓟757{query}: [miss]𝓛[ty]8642{Object} = {};
 let 𝓟758{queryParts}: [miss]𝓛[ty]8670{Array} = 𝓟754{queryString}.slice(𝓛8745{Number}).split(𝓛8743{String});
 {
 let 𝓟759{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 let 𝓟760{len}: [miss]𝓛[ty]8655{Number} = 𝓟758{queryParts}.length;
 while (𝓟759{i}.FirstBinaryOperator(𝓟760{len}))
 {
 {
 const 𝓟761{x}: [miss]𝓛[ty]8670{Array} = 𝓟758{queryParts}.access(𝓟759{i}).split(𝓛8743{String});
 𝓟757{query}.access(𝓟761{x}.access(𝓛8745{Number})) ⟵ (𝓟761{x}.access(𝓛8745{Number}) ? 𝓛8726{decodeURIComponent}(𝓟761{x}.access(𝓛8745{Number})) : 𝓛8743{String};
 }
 𝓛12546{POST_PlusPlusToken}(𝓟759{i})
 }
 }
 return 𝓟756 = 𝓟757{query}
}
function 𝓟762{stringifyQuery} (𝓟763{query}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8642{Object}),𝓟764{leadingCharacter}): (𝓟765: [miss]𝓛[ty]10051{String})
{
 let 𝓟766{keys}: [miss]𝓛[ty]8670{Array} = 𝓛8741{Object}.keys(𝓟763{query});
 if (𝓟766{keys}.length.EqualsEqualsEqualsToken(𝓛8745{Number}))
 {
 return 𝓟765 = 𝓛8743{String}
 }
 let 𝓟767{parts}: 𝓛[ty]8670{Array} = 𝓛8757{Array}();
 {
 let 𝓟768{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 let 𝓟769{len}: [miss]𝓛[ty]8655{Number} = 𝓟766{keys}.length;
 while (𝓟768{i}.FirstBinaryOperator(𝓟769{len}))
 {
 {
 let 𝓟770{key}: [miss]𝓛[ty]10051{String} = 𝓟766{keys}.access(𝓟768{i});
 let 𝓟771{value}: [miss]𝓛[ty]10051{String} = 𝓛8743{String}(𝓟763{query}.access(𝓟770{key}));
 𝓟767{parts}.push((𝓟771{value}.EqualsEqualsEqualsToken(𝓛8743{String}) ? 𝓟770{key} : 𝓟770{key}.PlusToken(𝓛8743{String}).PlusToken(𝓛8732{encodeURIComponent}(𝓟771{value}))))
 }
 𝓛12546{POST_PlusPlusToken}(𝓟768{i})
 }
 }
 return 𝓟765 = 𝓟764{leadingCharacter}.PlusToken(𝓟767{parts}.join(𝓛8743{String}))
}