LibAcc: 0.7126=62/87, ProjAcc: 1.0000=0/0, Missing: 132

Module: src/cli/tasks/extract.task

type 𝓟[ty]1154{ExtractTaskOptionsInterface} = {replace: 𝓛[ty]8666{Boolean}, verbose: 𝓛[ty]8666{Boolean}, patterns: 𝓛[ty]8670{Array}, clean: 𝓛[ty]8666{Boolean}, sort: 𝓛[ty]8666{Boolean}}
function 𝓟2{CONSTRUCTOR} (𝓟3{_input}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}),𝓟4{_output}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟5{options}: [OOV]𝓟[ty]1154{ExtractTaskOptionsInterface}): (𝓟[ty]9{ExtractTask})
{
 const 𝓟[ty]9{ExtractTask};
 const 𝓟[ty]9{ExtractTask};
 𝓟[ty]9{ExtractTask}._parsers ⟵ 𝓛8757{Array}();
 𝓟[ty]9{ExtractTask}._options ⟵ {replace: 𝓛8744{Boolean},verbose: 𝓛8744{Boolean},patterns: 𝓛8757{Array}(),clean: 𝓛8744{Boolean},sort: 𝓛8744{Boolean}};
 𝓟[ty]9{ExtractTask}._options ⟵ 𝓛8741{Object}.assign({},𝓟[ty]9{ExtractTask}._options,𝓟5{options});
}
class 𝓟[ty]9{ExtractTask} extends 𝓟[ty]1146{TaskInterface}{
 𝓟11{_options}: [OOV]𝓟[ty]1154{ExtractTaskOptionsInterface};
 𝓟12{_parsers}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8670{Array});
 𝓟13{_compiler}: [OOV]𝓟[ty]1149{CompilerInterface};
 function 𝓟20{setCompiler} (𝓟21{compiler}: [OOV]𝓟[ty]1149{CompilerInterface}): (𝓟22: [OOV]any)
 {
 𝓟[ty]9{ExtractTask}._compiler ⟵ 𝓟21{compiler};
 return 𝓟22 = 𝓟[ty]9{ExtractTask}
 }
 function 𝓟50{_readDir} (𝓟51{dir}: 𝓛[ty]10051{String},𝓟52{patterns}: 𝓛[ty]8670{Array}): (𝓟53: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8670{Array}))
 {
 function 𝓟54{$Lambda31} (𝓟55{results},𝓟56{pattern}): (𝓟57: [OOV]any)
 {
 function 𝓟58{$Lambda32} (𝓟59{path}): (𝓟60: [OOV]any)
 {
 return 𝓟60 = 𝓛7384{statSync}(𝓟59{path}).isFile()
 }
 return 𝓟57 = 𝓛42860{sync}(𝓟51{dir}.PlusToken(𝓟56{pattern})).filter(𝓟58{$Lambda32}).concat(𝓟55{results})
 }
 return 𝓟53 = 𝓟52{patterns}.reduce(𝓟54{$Lambda31},𝓛8757{Array}())
 }
 function 𝓟14{execute} (): (𝓟15: 𝓛[ty]10033{Void})
 {
 if (𝓛12548{ExclamationToken}(𝓟[ty]9{ExtractTask}._parsers))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 if (𝓛12548{ExclamationToken}(𝓟[ty]9{ExtractTask}._compiler))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 const 𝓟16{collection}: [OOV]𝓟[ty]346{TranslationCollection} = 𝓟[ty]9{ExtractTask}._extract();
 𝓟[ty]9{ExtractTask}._out(𝓛1{<UNKNOWN>}(𝓛8743{String}),𝓟16{collection}.count())
 𝓟[ty]9{ExtractTask}._save(𝓟16{collection})
 }
 function 𝓟23{_extract} (): (𝓟24: [OOV]𝓟[ty]346{TranslationCollection})
 {
 𝓟[ty]9{ExtractTask}._out(𝓛1{<UNKNOWN>}(𝓛8743{String}))
 let 𝓟25{collection}: [OOV]𝓟[ty]346{TranslationCollection} = 𝓟341{CONSTRUCTOR}();
 function 𝓟26{$Lambda27} (𝓟27{dir}): (𝓟28: [miss]𝓛[ty]10033{Void})
 {
 function 𝓟29{$Lambda28} (𝓟30{path}): (𝓟31: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]9{ExtractTask}._options.verbose.AmpersandAmpersandToken(𝓟[ty]9{ExtractTask}._out(𝓛1{<UNKNOWN>}(𝓛8743{String}),𝓟30{path}))
 const 𝓟32{contents}: 𝓛[ty]10051{String} = 𝓛7899{readFileSync}(𝓟30{path},𝓛8743{String});
 function 𝓟33{$Lambda29} (𝓟34{parser}: [OOV]𝓟[ty]1153{ParserInterface}): (𝓟35: [miss]𝓛[ty]10033{Void})
 {
 𝓟25{collection} ⟵ 𝓟25{collection}.union(𝓟34{parser}.extract(𝓟32{contents},𝓟30{path}));
 }
 𝓟[ty]9{ExtractTask}._parsers.forEach(𝓟33{$Lambda29})
 }
 𝓟[ty]9{ExtractTask}._readDir(𝓟27{dir},𝓟[ty]9{ExtractTask}._options.patterns).forEach(𝓟29{$Lambda28})
 }
 𝓟[ty]9{ExtractTask}._input.forEach(𝓟26{$Lambda27})
 return 𝓟24 = 𝓟25{collection}
 }
 function 𝓟17{setParsers} (𝓟18{parsers}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array})): (𝓟19: [OOV]any)
 {
 𝓟[ty]9{ExtractTask}._parsers ⟵ 𝓟18{parsers};
 return 𝓟19 = 𝓟[ty]9{ExtractTask}
 }
 function 𝓟36{_save} (𝓟37{collection}: [OOV]𝓟[ty]346{TranslationCollection}): (𝓟38: 𝓛[ty]10033{Void})
 {
 function 𝓟39{$Lambda30} (𝓟40{output}): (𝓟41: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟42{normalizedOutput}: 𝓛[ty]10051{String} = 𝓛2366{resolve}(𝓟40{output});
 let 𝓟43{dir}: 𝓛[ty]10051{String} = 𝓟42{normalizedOutput};
 let 𝓟44{filename}: 𝓛[ty]10051{String} = 𝓛12554{$Template}(𝓟[ty]9{ExtractTask}._compiler.extension);
 if (𝓛12548{ExclamationToken}(𝓛7984{existsSync}(𝓟42{normalizedOutput})).BarBarToken(𝓛12548{ExclamationToken}(𝓛7384{statSync}(𝓟42{normalizedOutput}).isDirectory())))
 {
 𝓟43{dir} ⟵ 𝓛2376{dirname}(𝓟42{normalizedOutput});
 𝓟44{filename} ⟵ 𝓛2379{basename}(𝓟42{normalizedOutput});
 }
 const 𝓟45{outputPath}: 𝓛[ty]10051{String} = 𝓛2363{join}(𝓟43{dir},𝓟44{filename});
 let 𝓟46{processedCollection}: [OOV]𝓟[ty]346{TranslationCollection} = 𝓟37{collection};
 𝓟[ty]9{ExtractTask}._out(𝓛1{<UNKNOWN>}(𝓛8743{String}),𝓟45{outputPath})
 if (𝓛7984{existsSync}(𝓟45{outputPath}).AmpersandAmpersandToken(𝓛12548{ExclamationToken}(𝓟[ty]9{ExtractTask}._options.replace)))
 {
 const 𝓟47{existingCollection}: [OOV]𝓟[ty]346{TranslationCollection} = 𝓟[ty]9{ExtractTask}._compiler.parse(𝓛7899{readFileSync}(𝓟45{outputPath},𝓛8743{String}));
 if (𝓛12548{ExclamationToken}(𝓟47{existingCollection}.isEmpty()))
 {
 𝓟46{processedCollection} ⟵ 𝓟46{processedCollection}.union(𝓟47{existingCollection});
 𝓟[ty]9{ExtractTask}._out(𝓛1{<UNKNOWN>}(𝓛8743{String}),𝓟47{existingCollection}.count())
 }
 if (𝓟[ty]9{ExtractTask}._options.clean)
 {
 const 𝓟48{collectionCount}: [miss]𝓛[ty]8655{Number} = 𝓟46{processedCollection}.count();
 𝓟46{processedCollection} ⟵ 𝓟46{processedCollection}.intersect(𝓟37{collection});
 const 𝓟49{removeCount}: [miss]𝓛[ty]8655{Number} = 𝓟48{collectionCount}.MinusToken(𝓟46{processedCollection}.count());
 if (𝓟49{removeCount}.GreaterThanToken(𝓛8745{Number}))
 {
 𝓟[ty]9{ExtractTask}._out(𝓛1{<UNKNOWN>}(𝓛8743{String}),𝓟49{removeCount})
 }
 }
 }
 if (𝓟[ty]9{ExtractTask}._options.sort)
 {
 𝓟46{processedCollection} ⟵ 𝓟46{processedCollection}.sort();
 𝓟[ty]9{ExtractTask}._out(𝓛1{<UNKNOWN>}(𝓛8743{String}))
 }
 if (𝓛12548{ExclamationToken}(𝓛7984{existsSync}(𝓟43{dir})))
 {
 𝓛46361{sync}(𝓟43{dir})
 𝓟[ty]9{ExtractTask}._out(𝓛1{<UNKNOWN>}(𝓛8743{String}),𝓟43{dir})
 }
 𝓛7919{writeFileSync}(𝓟45{outputPath},𝓟[ty]9{ExtractTask}._compiler.compile(𝓟46{processedCollection}))
 𝓟[ty]9{ExtractTask}._out(𝓛1{<UNKNOWN>}(𝓛8743{String}))
 }
 𝓟[ty]9{ExtractTask}._output.forEach(𝓟39{$Lambda30})
 }
 function 𝓟61{_out} (𝓟62{args}: 𝓛[ty]8670{Array}): (𝓟63: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}.apply(𝓟[ty]9{ExtractTask},𝓛10035{arguments})
 }
}

Module: src/index

Module: src/parsers/directive.parser

const 𝓟64{$} = 𝓛1{<UNKNOWN>}(𝓛8743{String},{xmlMode: 𝓛8744{Boolean}});
function 𝓟65{CONSTRUCTOR} (): (𝓟[ty]69{DirectiveParser})
{
 const 𝓟[ty]69{DirectiveParser};
 const 𝓟[ty]69{DirectiveParser};
}
class 𝓟[ty]69{DirectiveParser} extends 𝓟[ty]240{AbstractTemplateParser} with 𝓟[ty]1153{ParserInterface}{
 function 𝓟71{extract} (𝓟72{contents}: 𝓛[ty]10051{String},𝓟73{path}: 𝓛[ty]10051{String}): (𝓟74: [OOV]𝓟[ty]346{TranslationCollection})
 {
 if (𝓛1{<UNKNOWN>}(𝓟[ty]69{DirectiveParser}._isAngularComponent(𝓟73{path})))
 {
 𝓟72{contents} ⟵ 𝓟[ty]69{DirectiveParser}._extractInlineTemplate(𝓟72{contents});
 }
 return 𝓟74 = 𝓟[ty]69{DirectiveParser}._parseTemplate(𝓟72{contents})
 }
 function 𝓟75{_parseTemplate} (𝓟76{template}: 𝓛[ty]10051{String}): (𝓟77: [OOV]𝓟[ty]346{TranslationCollection})
 {
 let 𝓟78{collection}: [OOV]𝓟[ty]346{TranslationCollection} = 𝓟341{CONSTRUCTOR}();
 𝓟76{template} ⟵ 𝓟[ty]69{DirectiveParser}._normalizeTemplateAttributes(𝓟76{template});
 const 𝓟79{selector}: [miss]𝓛[ty]10051{String} = 𝓛8743{String};
 function 𝓟80{$Lambda9} (𝓟81{i}: 𝓛[ty]8655{Number},𝓟82{element}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟83: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟84{$element} = 𝓟64{$}(𝓟82{element});
 const 𝓟85{attr} = 𝓟84{$element}.attr(𝓛8743{String}).BarBarToken(𝓟84{$element}.attr(𝓛8743{String}));
 if (𝓟85{attr})
 {
 𝓟78{collection} ⟵ 𝓟78{collection}.add(𝓟85{attr});
 }
 else
 {
 function 𝓟86{$Lambda10} (𝓟87{node}): (𝓟88: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟88 = 𝓟87{node}.type.EqualsEqualsEqualsToken(𝓛8743{String})
 }
 function 𝓟89{$Lambda11} (𝓟90{node}): (𝓟91: [OOV]any)
 {
 return 𝓟91 = 𝓟90{node}.nodeValue.trim()
 }
 function 𝓟92{$Lambda12} (𝓟93{text}): (𝓟94: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟94 = 𝓟93{text}.length.GreaterThanToken(𝓛8745{Number})
 }
 function 𝓟95{$Lambda13} (𝓟96{text}): (𝓟97: [OOV]𝓟[ty]346{TranslationCollection})
 {
 return 𝓟97 = 𝓟78{collection}.FirstAssignment(𝓟78{collection}.add(𝓟96{text}))
 }
 𝓟84{$element}.contents().toArray().filter(𝓟86{$Lambda10}).map(𝓟89{$Lambda11}).filter(𝓟92{$Lambda12}).forEach(𝓟95{$Lambda13})
 }
 }
 𝓟64{$}(𝓟76{template}).find(𝓟79{selector}).addBack(𝓟79{selector}).each(𝓟80{$Lambda9})
 return 𝓟77 = 𝓟78{collection}
 }
 function 𝓟98{_normalizeTemplateAttributes} (𝓟99{template}: 𝓛[ty]10051{String}): (𝓟100: 𝓛[ty]10051{String})
 {
 return 𝓟100 = 𝓟99{template}.replace(𝓛8748{RegExp},𝓛8743{String})
 }
}

Module: src/parsers/abstract-ast.parser

function 𝓟101{CONSTRUCTOR} (): (𝓟[ty]105{AbstractAstParser})
{
 const 𝓟[ty]105{AbstractAstParser};
 const 𝓟[ty]105{AbstractAstParser};
}
class 𝓟[ty]105{AbstractAstParser}{
 𝓟107{_sourceFile}: [OOV]𝓛[ty]2{<UNKNOWN>};
 function 𝓟108{_createSourceFile} (𝓟109{path}: 𝓛[ty]10051{String},𝓟110{contents}: 𝓛[ty]10051{String}): (𝓟111: [OOV]𝓛[ty]2{<UNKNOWN>})
 {
 return 𝓟111 = 𝓛1{<UNKNOWN>}(𝓟109{path},𝓟110{contents},𝓛12563{undefined},𝓛8744{Boolean})
 }
 function 𝓟132{_printAllChildren} (𝓟133{sourceFile}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟134{node}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟135{depth}): (𝓟136: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8757{Array}.CONSTRUCTOR(𝓟135{depth}.PlusToken(𝓛8745{Number})).join(𝓛8743{String}),𝓛12554{$Template}(𝓟134{node}.kind),𝓟[ty]105{AbstractAstParser}._syntaxKindToName(𝓟134{node}.kind),𝓛12554{$Template}(𝓟134{node}.pos,𝓟134{node}.end),𝓛8743{String},𝓟134{node}.getFullText(𝓟133{sourceFile}).trim())
 𝓛12546{POST_PlusPlusToken}(𝓟135{depth})
 function 𝓟137{$Lambda8} (𝓟138{childNode}): (𝓟139: [miss]𝓛[ty]10033{Void})
 {
 return 𝓟139 = 𝓟[ty]105{AbstractAstParser}._printAllChildren(𝓟133{sourceFile},𝓟138{childNode},𝓟135{depth})
 }
 𝓟134{node}.getChildren(𝓟133{sourceFile}).forEach(𝓟137{$Lambda8})
 }
 function 𝓟129{_syntaxKindToName} (𝓟130{kind}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟131: 𝓛[ty]10051{String})
 {
 return 𝓟131 = 𝓛1{<UNKNOWN>}.access(𝓟130{kind})
 }
 function 𝓟119{_findNodes} (𝓟120{node}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟121{kind}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟122: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8670{Array}))
 {
 const 𝓟123{childrenNodes}: 𝓛[ty]8670{Array} = 𝓟120{node}.getChildren(𝓟[ty]105{AbstractAstParser}._sourceFile);
 const 𝓟124{initialValue}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8670{Array}) = (𝓟120{node}.kind.EqualsEqualsEqualsToken(𝓟121{kind}) ? 𝓛8757{Array}(𝓟120{node}) : 𝓛8757{Array}();
 function 𝓟125{$Lambda7} (𝓟126{result}: 𝓛[ty]8670{Array},𝓟127{childNode}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟128: [miss]𝓛[ty]8670{Array})
 {
 return 𝓟128 = 𝓟126{result}.concat(𝓟[ty]105{AbstractAstParser}._findNodes(𝓟127{childNode},𝓟121{kind}))
 }
 return 𝓟122 = 𝓟123{childrenNodes}.reduce(𝓟125{$Lambda7},𝓟124{initialValue})
 }
 function 𝓟112{_getCallArgStrings} (𝓟113{callNode}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟114: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
 {
 if (𝓛12548{ExclamationToken}(𝓟113{callNode}.arguments.length))
 {
 }
 const 𝓟115{firstArg}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟113{callNode}.arguments.access(𝓛8745{Number});
 𝓛12549{$Switch}(𝓟115{firstArg}.kind)
 𝓛12561{$Case}(𝓛1{<UNKNOWN>}.StringLiteral)
 𝓛12561{$Case}(𝓛1{<UNKNOWN>}.FirstTemplateToken)
 return 𝓟114 = 𝓛8757{Array}(𝓟115{firstArg} as 𝓛[ty]2{<UNKNOWN>}.text)
 𝓛12561{$Case}(𝓛1{<UNKNOWN>}.ArrayLiteralExpression)
 function 𝓟116{$Lambda6} (𝓟117{element}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟118: [miss]𝓛[ty]10051{String})
 {
 return 𝓟118 = 𝓟117{element}.text
 }
 return 𝓟114 = 𝓟115{firstArg} as 𝓛[ty]2{<UNKNOWN>}.elements.map(𝓟116{$Lambda6})
 𝓛12561{$Case}(𝓛1{<UNKNOWN>}.Identifier)
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓛1{<UNKNOWN>}(𝓛12554{$Template}(𝓟[ty]105{AbstractAstParser}._syntaxKindToName(𝓟115{firstArg}.kind)),𝓟115{firstArg})
 }
}

Module: src/parsers/service.parser

function 𝓟140{CONSTRUCTOR} (): (𝓟[ty]144{ServiceParser})
{
 const 𝓟[ty]144{ServiceParser};
 const 𝓟[ty]144{ServiceParser};
}
class 𝓟[ty]144{ServiceParser} extends 𝓟[ty]105{AbstractAstParser} with 𝓟[ty]1153{ParserInterface}{
 𝓟146{_sourceFile}: [OOV]𝓛[ty]2{<UNKNOWN>};
 function 𝓟175{_findConstructorNode} (𝓟176{node}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟177: [OOV]𝓛[ty]2{<UNKNOWN>})
 {
 const 𝓟178{constructorNodes}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]144{ServiceParser}._findNodes(𝓟176{node},𝓛1{<UNKNOWN>}.Constructor) as 𝓛[ty]8670{Array};
 if (𝓟178{constructorNodes})
 {
 return 𝓟177 = 𝓟178{constructorNodes}.access(𝓛8745{Number})
 }
 }
 function 𝓟172{_findClassNodes} (𝓟173{node}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟174: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]8670{Array}))
 {
 return 𝓟174 = 𝓟[ty]144{ServiceParser}._findNodes(𝓟173{node},𝓛1{<UNKNOWN>}.ClassDeclaration) as 𝓛[ty]8670{Array}
 }
 function 𝓟163{_findTranslateServicePropertyName} (𝓟164{constructorNode}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟165: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10051{String}))
 {
 if (𝓛12548{ExclamationToken}(𝓟164{constructorNode}))
 {
 return 𝓟165 = 𝓛12563{undefined}
 }
 function 𝓟166{$Lambda18} (𝓟167{parameter}): (𝓟168: [miss]𝓛[ty]8666{Boolean})
 {
 if (𝓛12548{ExclamationToken}(𝓟167{parameter}.modifiers))
 {
 return 𝓟168 = 𝓛8744{Boolean}
 }
 if (𝓛12548{ExclamationToken}(𝓟167{parameter}.type))
 {
 return 𝓟168 = 𝓛8744{Boolean}
 }
 const 𝓟169{parameterType}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟167{parameter}.type as 𝓛[ty]2{<UNKNOWN>}.typeName as 𝓛[ty]2{<UNKNOWN>};
 if (𝓛12548{ExclamationToken}(𝓟169{parameterType}))
 {
 return 𝓟168 = 𝓛8744{Boolean}
 }
 const 𝓟170{className}: 𝓛[ty]10051{String} = 𝓟169{parameterType}.text;
 if (𝓟170{className}.ExclamationEqualsEqualsToken(𝓛8743{String}))
 {
 return 𝓟168 = 𝓛8744{Boolean}
 }
 return 𝓟168 = 𝓛8744{Boolean}
 }
 const 𝓟171{result}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟164{constructorNode}.parameters.find(𝓟166{$Lambda18});
 if (𝓟171{result})
 {
 return 𝓟165 = 𝓟171{result}.name as 𝓛[ty]2{<UNKNOWN>}.text
 }
 }
 function 𝓟179{_findCallNodes} (𝓟180{node}: [OOV]𝓛[ty]2{<UNKNOWN>},𝓟181{propertyIdentifier}: 𝓛[ty]10051{String}): (𝓟182: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8670{Array}))
 {
 let 𝓟183{callNodes}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]144{ServiceParser}._findNodes(𝓟180{node},𝓛1{<UNKNOWN>}.CallExpression) as 𝓛[ty]8670{Array};
 function 𝓟184{$Lambda19} (𝓟185{callNode}): (𝓟186: [miss]𝓛[ty]8666{Boolean})
 {
 if (𝓟185{callNode}.arguments.length.FirstBinaryOperator(𝓛8745{Number}))
 {
 return 𝓟186 = 𝓛8744{Boolean}
 }
 const 𝓟187{propAccess}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟185{callNode}.getChildAt(𝓛8745{Number}).getChildAt(𝓛8745{Number}) as 𝓛[ty]2{<UNKNOWN>};
 if (𝓛12548{ExclamationToken}(𝓟187{propAccess}).BarBarToken(𝓟187{propAccess}.kind.ExclamationEqualsEqualsToken(𝓛1{<UNKNOWN>}.PropertyAccessExpression)))
 {
 return 𝓟186 = 𝓛8744{Boolean}
 }
 if (𝓛12548{ExclamationToken}(𝓟187{propAccess}.getFirstToken()).BarBarToken(𝓟187{propAccess}.getFirstToken().kind.ExclamationEqualsEqualsToken(𝓛1{<UNKNOWN>}.ThisKeyword)))
 {
 return 𝓟186 = 𝓛8744{Boolean}
 }
 if (𝓟187{propAccess}.name.text.ExclamationEqualsEqualsToken(𝓟181{propertyIdentifier}))
 {
 return 𝓟186 = 𝓛8744{Boolean}
 }
 const 𝓟188{methodAccess}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟185{callNode}.getChildAt(𝓛8745{Number}) as 𝓛[ty]2{<UNKNOWN>};
 if (𝓛12548{ExclamationToken}(𝓟188{methodAccess}).BarBarToken(𝓟188{methodAccess}.kind.ExclamationEqualsEqualsToken(𝓛1{<UNKNOWN>}.PropertyAccessExpression)))
 {
 return 𝓟186 = 𝓛8744{Boolean}
 }
 if (𝓛12548{ExclamationToken}(𝓟188{methodAccess}.name).BarBarToken(𝓟188{methodAccess}.name.text.ExclamationEqualsEqualsToken(𝓛8743{String}).AmpersandAmpersandToken(𝓟188{methodAccess}.name.text.ExclamationEqualsEqualsToken(𝓛8743{String})).AmpersandAmpersandToken(𝓟188{methodAccess}.name.text.ExclamationEqualsEqualsToken(𝓛8743{String}))))
 {
 return 𝓟186 = 𝓛8744{Boolean}
 }
 return 𝓟186 = 𝓛8744{Boolean}
 }
 𝓟183{callNodes} ⟵ 𝓟183{callNodes}.filter(𝓟184{$Lambda19});
 return 𝓟182 = 𝓟183{callNodes}
 }
 function 𝓟147{extract} (𝓟148{contents}: 𝓛[ty]10051{String},𝓟149{path}: 𝓛[ty]10051{String}): (𝓟150: [OOV]𝓟[ty]346{TranslationCollection})
 {
 let 𝓟151{collection}: [OOV]𝓟[ty]346{TranslationCollection} = 𝓟341{CONSTRUCTOR}();
 𝓟[ty]144{ServiceParser}._sourceFile ⟵ 𝓟[ty]144{ServiceParser}._createSourceFile(𝓟149{path},𝓟148{contents});
 const 𝓟152{classNodes}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]144{ServiceParser}._findClassNodes(𝓟[ty]144{ServiceParser}._sourceFile);
 function 𝓟153{$Lambda16} (𝓟154{classNode}): (𝓟155: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟156{constructorNode}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟[ty]144{ServiceParser}._findConstructorNode(𝓟154{classNode});
 if (𝓛12548{ExclamationToken}(𝓟156{constructorNode}))
 {
 }
 const 𝓟157{propertyName}: 𝓛[ty]10051{String} = 𝓟[ty]144{ServiceParser}._findTranslateServicePropertyName(𝓟156{constructorNode});
 if (𝓛12548{ExclamationToken}(𝓟157{propertyName}))
 {
 }
 const 𝓟158{callNodes}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]144{ServiceParser}._findCallNodes(𝓟154{classNode},𝓟157{propertyName});
 function 𝓟159{$Lambda17} (𝓟160{callNode}): (𝓟161: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟162{keys}: 𝓛[ty]8670{Array} = 𝓟[ty]144{ServiceParser}._getCallArgStrings(𝓟160{callNode});
 if (𝓟162{keys}.AmpersandAmpersandToken(𝓟162{keys}.length))
 {
 𝓟151{collection} ⟵ 𝓟151{collection}.addKeys(𝓟162{keys});
 }
 }
 𝓟158{callNodes}.forEach(𝓟159{$Lambda17})
 }
 𝓟152{classNodes}.forEach(𝓟153{$Lambda16})
 return 𝓟150 = 𝓟151{collection}
 }
}

Module: src/compilers/po.compiler

function 𝓟189{CONSTRUCTOR} (𝓟190{options}: [OOV]any): (𝓟[ty]194{PoCompiler})
{
 const 𝓟[ty]194{PoCompiler};
 const 𝓟[ty]194{PoCompiler};
 𝓟[ty]194{PoCompiler}.domain ⟵ 𝓛8743{String};
 𝓟[ty]194{PoCompiler}.extension ⟵ 𝓛8743{String};
}
class 𝓟[ty]194{PoCompiler} extends 𝓟[ty]1149{CompilerInterface}{
 𝓟196{extension}: [miss]𝓛[ty]10051{String};
 𝓟197{domain}: [miss]𝓛[ty]10051{String};
 function 𝓟198{compile} (𝓟199{collection}: [OOV]𝓟[ty]346{TranslationCollection}): (𝓟200: (𝓛[ty]10033{Void} ≠ 𝓛[ty]10051{String}))
 {
 function 𝓟201{$Lambda3} (𝓟202{translations},𝓟203{key}): (𝓟204: [OOV]any)
 {
 𝓟202{translations}.access(𝓟203{key}) ⟵ {msgid: 𝓟203{key},msgstr: 𝓟199{collection}.get(𝓟203{key})};
 return 𝓟204 = 𝓟202{translations}
 }
 const 𝓟205{data}: [miss]𝓛[ty]8642{Object} = {charset: 𝓛8743{String},headers: {'mime-version': 𝓛8743{String},'content-type': 𝓛8743{String},'content-transfer-encoding': 𝓛8743{String}},translations: {[this.domain]: 𝓛8741{Object}.keys(𝓟199{collection}.values).reduce(𝓟201{$Lambda3},{} as any)}};
 return 𝓟200 = 𝓛1{<UNKNOWN>}.compile(𝓟205{data},𝓛8743{String})
 }
 function 𝓟206{parse} (𝓟207{contents}: 𝓛[ty]10051{String}): (𝓟208: [OOV]𝓟[ty]346{TranslationCollection})
 {
 const 𝓟209{collection}: [OOV]𝓟[ty]346{TranslationCollection} = 𝓟341{CONSTRUCTOR}();
 const 𝓟210{po} = 𝓛1{<UNKNOWN>}.parse(𝓟207{contents},𝓛8743{String});
 if (𝓛12548{ExclamationToken}(𝓟210{po}.translations.hasOwnProperty(𝓟[ty]194{PoCompiler}.domain)))
 {
 return 𝓟208 = 𝓟209{collection}
 }
 function 𝓟211{$Lambda4} (𝓟212{key}): (𝓟213: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟213 = 𝓟212{key}.length.GreaterThanToken(𝓛8745{Number})
 }
 function 𝓟214{$Lambda5} (𝓟215{values},𝓟216{key}): (𝓟217: [OOV]𝓟[ty]1151{TranslationType})
 {
 𝓟215{values}.access(𝓟216{key}) ⟵ 𝓟210{po}.translations.access(𝓟[ty]194{PoCompiler}.domain).access(𝓟216{key}).msgstr.pop();
 return 𝓟217 = 𝓟215{values}
 }
 const 𝓟218{values}: [OOV]𝓟[ty]1151{TranslationType} = 𝓛8741{Object}.keys(𝓟210{po}.translations.access(𝓟[ty]194{PoCompiler}.domain)).filter(𝓟211{$Lambda4}).reduce(𝓟214{$Lambda5},{} as 𝓟[ty]1151{TranslationType});
 return 𝓟208 = 𝓟341{CONSTRUCTOR}(𝓟218{values})
 }
}

Module: src/compilers/namespaced-json.compiler

function 𝓟219{CONSTRUCTOR} (𝓟220{options}: [OOV]any): (𝓟[ty]224{NamespacedJsonCompiler})
{
 const 𝓟[ty]224{NamespacedJsonCompiler};
 const 𝓟[ty]224{NamespacedJsonCompiler};
 𝓟[ty]224{NamespacedJsonCompiler}.indentation ⟵ 𝓛8743{String};
 𝓟[ty]224{NamespacedJsonCompiler}.extension ⟵ 𝓛8743{String};
 if (𝓟220{options}.AmpersandAmpersandToken(𝓛12550{$TypeOf}(𝓟220{options}.indentation).ExclamationEqualsEqualsToken(𝓛8743{String})))
 {
 𝓟[ty]224{NamespacedJsonCompiler}.indentation ⟵ 𝓟220{options}.indentation;
 }
}
class 𝓟[ty]224{NamespacedJsonCompiler} extends 𝓟[ty]1149{CompilerInterface}{
 𝓟226{indentation}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String});
 𝓟227{extension}: [miss]𝓛[ty]10051{String};
 function 𝓟228{compile} (𝓟229{collection}: [OOV]𝓟[ty]346{TranslationCollection}): (𝓟230: (𝓛[ty]10033{Void} ≠ 𝓛[ty]10051{String}))
 {
 const 𝓟231{values}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8642{Object}) = 𝓛1{<UNKNOWN>}(𝓟229{collection}.values,{object: 𝓛8744{Boolean}});
 return 𝓟230 = 𝓛8756{JSON}.stringify(𝓟231{values},𝓛12563{undefined},𝓟[ty]224{NamespacedJsonCompiler}.indentation)
 }
 function 𝓟232{parse} (𝓟233{contents}: 𝓛[ty]10051{String}): (𝓟234: [OOV]𝓟[ty]346{TranslationCollection})
 {
 const 𝓟235{values}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8642{Object}) = 𝓛1{<UNKNOWN>}(𝓛8756{JSON}.parse(𝓟233{contents}));
 return 𝓟234 = 𝓟341{CONSTRUCTOR}(𝓟235{values})
 }
}

Module: src/parsers/abstract-template.parser

function 𝓟236{CONSTRUCTOR} (): (𝓟[ty]240{AbstractTemplateParser})
{
 const 𝓟[ty]240{AbstractTemplateParser};
 const 𝓟[ty]240{AbstractTemplateParser};
}
class 𝓟[ty]240{AbstractTemplateParser}{
 function 𝓟242{_isAngularComponent} (𝓟243{path}: 𝓛[ty]10051{String}): (𝓟244: 𝓛[ty]8666{Boolean})
 {
 return 𝓟244 = 𝓛8748{RegExp}.test(𝓟243{path})
 }
 function 𝓟245{_extractInlineTemplate} (𝓟246{contents}: 𝓛[ty]10051{String}): (𝓟247: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10051{String}))
 {
 const 𝓟248{regExp}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8662{RegExp}) = 𝓛8748{RegExp};
 const 𝓟249{match}: [OOV]𝓛[ty]8682{RegExpExecArray} = 𝓟248{regExp}.exec(𝓟246{contents});
 if (𝓟249{match}.ExclamationEqualsEqualsToken(𝓛12563{undefined}))
 {
 return 𝓟247 = 𝓟249{match}.access(𝓛8745{Number})
 }
 return 𝓟247 = 𝓛8743{String}
 }
}

Module: src/parsers/parser.interface

type 𝓟[ty]1153{ParserInterface} = {extract: (𝓛[ty]10051{String},𝓛[ty]10051{String})->𝓟[ty]346{TranslationCollection}}

Module: src/parsers/function.parser

function 𝓟251{CONSTRUCTOR} (𝓟252{options}: [OOV]any): (𝓟[ty]256{FunctionParser})
{
 const 𝓟[ty]256{FunctionParser};
 const 𝓟[ty]256{FunctionParser};
 𝓟[ty]256{FunctionParser}._functionIdentifier ⟵ 𝓛8743{String};
 𝓟[ty]256{FunctionParser}()
 if (𝓟252{options}.AmpersandAmpersandToken(𝓛12550{$TypeOf}(𝓟252{options}.identifier).ExclamationEqualsEqualsToken(𝓛8743{String})))
 {
 𝓟[ty]256{FunctionParser}._functionIdentifier ⟵ 𝓟252{options}.identifier;
 }
}
class 𝓟[ty]256{FunctionParser} extends 𝓟[ty]105{AbstractAstParser} with 𝓟[ty]1153{ParserInterface}{
 𝓟258{_functionIdentifier}: (𝓛[ty]8666{Boolean} ≠ 𝓛[ty]10051{String});
 function 𝓟259{extract} (𝓟260{contents}: 𝓛[ty]10051{String},𝓟261{path}: 𝓛[ty]10051{String}): (𝓟262: [OOV]𝓟[ty]346{TranslationCollection})
 {
 let 𝓟263{collection}: [OOV]𝓟[ty]346{TranslationCollection} = 𝓟341{CONSTRUCTOR}();
 𝓟[ty]256{FunctionParser}._sourceFile ⟵ 𝓟[ty]256{FunctionParser}._createSourceFile(𝓟261{path},𝓟260{contents});
 const 𝓟264{callNodes}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]256{FunctionParser}._findCallNodes();
 function 𝓟265{$Lambda14} (𝓟266{callNode}): (𝓟267: [miss]𝓛[ty]10033{Void})
 {
 const 𝓟268{keys}: 𝓛[ty]8670{Array} = 𝓟[ty]256{FunctionParser}._getCallArgStrings(𝓟266{callNode});
 if (𝓟268{keys}.AmpersandAmpersandToken(𝓟268{keys}.length))
 {
 𝓟263{collection} ⟵ 𝓟263{collection}.addKeys(𝓟268{keys});
 }
 }
 𝓟264{callNodes}.forEach(𝓟265{$Lambda14})
 return 𝓟262 = 𝓟263{collection}
 }
 function 𝓟269{_findCallNodes} (𝓟270{node}: [OOV]𝓛[ty]2{<UNKNOWN>}): (𝓟271: (𝓛[ty]10033{Void} ≠ 𝓛[ty]8670{Array}))
 {
 if (𝓛12548{ExclamationToken}(𝓟270{node}))
 {
 𝓟270{node} ⟵ 𝓟[ty]256{FunctionParser}._sourceFile;
 }
 let 𝓟272{callNodes}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]256{FunctionParser}._findNodes(𝓟270{node},𝓛1{<UNKNOWN>}.CallExpression) as 𝓛[ty]8670{Array};
 function 𝓟273{$Lambda15} (𝓟274{callNode}): (𝓟275: [miss]𝓛[ty]8666{Boolean})
 {
 if (𝓟274{callNode}.arguments.length.FirstBinaryOperator(𝓛8745{Number}))
 {
 return 𝓟275 = 𝓛8744{Boolean}
 }
 const 𝓟276{identifier}: [miss]𝓛[ty]10051{String} = 𝓟274{callNode}.getChildAt(𝓛8745{Number}) as 𝓛[ty]2{<UNKNOWN>}.text;
 if (𝓟276{identifier}.ExclamationEqualsEqualsToken(𝓟[ty]256{FunctionParser}._functionIdentifier))
 {
 return 𝓟275 = 𝓛8744{Boolean}
 }
 return 𝓟275 = 𝓛8744{Boolean}
 }
 𝓟272{callNodes} ⟵ 𝓟272{callNodes}.filter(𝓟273{$Lambda15});
 return 𝓟271 = 𝓟272{callNodes}
 }
}

Module: src/cli/cli

function 𝓟277{$Lambda0} (𝓟278{options}): (𝓟279: [miss]𝓛[ty]8666{Boolean})
{
 function 𝓟280{$Lambda1} (𝓟281{dir}: 𝓛[ty]10051{String}): (𝓟282: [miss]𝓛[ty]10033{Void})
 {
 if (𝓛12548{ExclamationToken}(𝓛7984{existsSync}(𝓟281{dir})).BarBarToken(𝓛12548{ExclamationToken}(𝓛7384{statSync}(𝓟281{dir}).isDirectory())))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛12554{$Template}(𝓟281{dir}))
 }
 }
 𝓟278{options}.input.forEach(𝓟280{$Lambda1})
 return 𝓟279 = 𝓛8744{Boolean}
}
const 𝓟283{cli} = 𝓛1{<UNKNOWN>}(𝓛8743{String}).version(𝓛10097{require}(𝓛10058{__dirname}.PlusToken(𝓛8743{String})).version).alias(𝓛8743{String},𝓛8743{String}).help(𝓛8743{String}).alias(𝓛8743{String},𝓛8743{String}).option(𝓛8743{String},{normalize: 𝓛8744{Boolean},describe: 𝓛8743{String},alias: 𝓛8743{String},default: 𝓛1{<UNKNOWN>}.PWD,type: 𝓛8743{String}}).check(𝓟277{$Lambda0}).option(𝓛8743{String},{alias: 𝓛8743{String},describe: 𝓛8743{String},type: 𝓛8743{String},default: 𝓛8757{Array}(𝓛8743{String},𝓛8743{String})}).option(𝓛8743{String},{normalize: 𝓛8744{Boolean},describe: 𝓛8743{String},alias: 𝓛8743{String},type: 𝓛8743{String},required: 𝓛8744{Boolean}}).option(𝓛8743{String},{alias: 𝓛8743{String},describe: 𝓛8743{String},default: 𝓛8744{Boolean},type: 𝓛8743{String}}).option(𝓛8743{String},{choices: 𝓛8757{Array}(𝓛8743{String},𝓛8743{String},𝓛8743{String}),describe: 𝓛8743{String},alias: 𝓛8743{String},default: 𝓛8743{String},type: 𝓛8743{String}}).option(𝓛8743{String},{alias: 𝓛8743{String},describe: 𝓛8743{String},default: 𝓛8743{String},type: 𝓛8743{String}}).option(𝓛8743{String},{alias: 𝓛8743{String},describe: 𝓛8743{String},default: 𝓛8744{Boolean},type: 𝓛8743{String}}).option(𝓛8743{String},{alias: 𝓛8743{String},describe: 𝓛8743{String},default: 𝓛8744{Boolean},type: 𝓛8743{String}}).option(𝓛8743{String},{alias: 𝓛8743{String},describe: 𝓛8743{String},default: 𝓛8744{Boolean},type: 𝓛8743{String}}).option(𝓛8743{String},{alias: 𝓛8743{String},describe: 𝓛8743{String},default: 𝓛8744{Boolean},type: 𝓛8743{String}}).exitProcess(𝓛8744{Boolean}).parse(𝓛1{<UNKNOWN>});
const 𝓟284{extract}: [OOV]𝓟[ty]9{ExtractTask} = 𝓟2{CONSTRUCTOR}(𝓟283{cli}.input,𝓟283{cli}.output,{replace: 𝓟283{cli}.replace,sort: 𝓟283{cli}.sort,clean: 𝓟283{cli}.clean,patterns: 𝓟283{cli}.patterns});
const 𝓟285{compiler}: [OOV]𝓟[ty]1149{CompilerInterface} = 𝓟333{create}(𝓟283{cli}.format,{indentation: 𝓟283{cli}.formatIndentation});
𝓟284{extract}.setCompiler(𝓟285{compiler})
const 𝓟286{parsers}: 𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓟290{CONSTRUCTOR}(),𝓟65{CONSTRUCTOR}(),𝓟140{CONSTRUCTOR}());
if (𝓟283{cli}.marker)
{
 𝓟286{parsers}.push(𝓟251{CONSTRUCTOR}({identifier: 𝓟283{cli}.marker}))
}
𝓟284{extract}.setParsers(𝓟286{parsers})
𝓟284{extract}.execute()

Module: src/utils/utils

function 𝓟287{_} (𝓟288{key}: [OOV]any): (𝓟289: [OOV]any)
{
 return 𝓟289 = 𝓟288{key}
}

Module: src/parsers/pipe.parser

function 𝓟290{CONSTRUCTOR} (): (𝓟[ty]294{PipeParser})
{
 const 𝓟[ty]294{PipeParser};
 const 𝓟[ty]294{PipeParser};
}
class 𝓟[ty]294{PipeParser} extends 𝓟[ty]240{AbstractTemplateParser} with 𝓟[ty]1153{ParserInterface}{
 function 𝓟296{extract} (𝓟297{contents}: 𝓛[ty]10051{String},𝓟298{path}: 𝓛[ty]10051{String}): (𝓟299: [OOV]𝓟[ty]346{TranslationCollection})
 {
 if (𝓛1{<UNKNOWN>}(𝓟[ty]294{PipeParser}._isAngularComponent(𝓟298{path})))
 {
 𝓟297{contents} ⟵ 𝓟[ty]294{PipeParser}._extractInlineTemplate(𝓟297{contents});
 }
 return 𝓟299 = 𝓟[ty]294{PipeParser}._parseTemplate(𝓟297{contents})
 }
 function 𝓟300{_parseTemplate} (𝓟301{template}: 𝓛[ty]10051{String}): (𝓟302: [OOV]𝓟[ty]346{TranslationCollection})
 {
 let 𝓟303{collection}: [OOV]𝓟[ty]346{TranslationCollection} = 𝓟341{CONSTRUCTOR}();
 const 𝓟304{regExp}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8662{RegExp}) = 𝓛8748{RegExp};
 let 𝓟305{matches}: [OOV]𝓛[ty]8682{RegExpExecArray};
 while (𝓟305{matches}.FirstAssignment(𝓟304{regExp}.exec(𝓟301{template})))
 {
 𝓟303{collection} ⟵ 𝓟303{collection}.add(𝓟305{matches}.access(𝓛8745{Number}).split(𝓛8743{String}).join(𝓛8743{String}));
 }
 return 𝓟302 = 𝓟303{collection}
 }
}

Module: src/compilers/compiler.interface

type 𝓟[ty]1149{CompilerInterface} = {extension: 𝓛[ty]10051{String}, compile: (𝓟[ty]346{TranslationCollection})->𝓛[ty]10051{String}, parse: (𝓛[ty]10051{String})->𝓟[ty]346{TranslationCollection}}

Module: src/compilers/json.compiler

function 𝓟307{CONSTRUCTOR} (𝓟308{options}: [OOV]any): (𝓟[ty]312{JsonCompiler})
{
 const 𝓟[ty]312{JsonCompiler};
 const 𝓟[ty]312{JsonCompiler};
 𝓟[ty]312{JsonCompiler}.indentation ⟵ 𝓛8743{String};
 𝓟[ty]312{JsonCompiler}.extension ⟵ 𝓛8743{String};
 if (𝓟308{options}.AmpersandAmpersandToken(𝓛12550{$TypeOf}(𝓟308{options}.indentation).ExclamationEqualsEqualsToken(𝓛8743{String})))
 {
 𝓟[ty]312{JsonCompiler}.indentation ⟵ 𝓟308{options}.indentation;
 }
}
class 𝓟[ty]312{JsonCompiler} extends 𝓟[ty]1149{CompilerInterface}{
 𝓟314{indentation}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String});
 𝓟315{extension}: [miss]𝓛[ty]10051{String};
 function 𝓟316{compile} (𝓟317{collection}: [OOV]𝓟[ty]346{TranslationCollection}): (𝓟318: 𝓛[ty]10051{String})
 {
 return 𝓟318 = 𝓛8756{JSON}.stringify(𝓟317{collection}.values,𝓛12563{undefined},𝓟[ty]312{JsonCompiler}.indentation)
 }
 function 𝓟319{parse} (𝓟320{contents}: (𝓛[ty]8655{Number} ≠ 𝓛[ty]10051{String})): (𝓟321: [OOV]𝓟[ty]346{TranslationCollection})
 {
 let 𝓟322{values}: [OOV]any = 𝓛8756{JSON}.parse(𝓟320{contents});
 if (𝓟[ty]312{JsonCompiler}._isNamespacedJsonFormat(𝓟322{values}))
 {
 𝓟322{values} ⟵ 𝓛1{<UNKNOWN>}(𝓟322{values});
 }
 return 𝓟321 = 𝓟341{CONSTRUCTOR}(𝓟322{values})
 }
 function 𝓟323{_isNamespacedJsonFormat} (𝓟324{values}: [OOV]any): (𝓟325: 𝓛[ty]8666{Boolean})
 {
 function 𝓟326{$Lambda2} (𝓟327{key}): (𝓟328: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟328 = 𝓛12550{$TypeOf}(𝓟324{values}.access(𝓟327{key})).EqualsEqualsEqualsToken(𝓛8743{String})
 }
 return 𝓟325 = 𝓛8741{Object}.keys(𝓟324{values}).some(𝓟326{$Lambda2})
 }
}

Module: src/compilers/compiler.factory

function 𝓟329{CONSTRUCTOR} (): (𝓟[ty]337{CompilerFactory})
{
 const 𝓟[ty]337{CompilerFactory};
 const 𝓟[ty]337{CompilerFactory};
}
function 𝓟333{create} (𝓟334{format}: 𝓛[ty]10051{String},𝓟335{options}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8642{Object})): (𝓟336: [OOV]𝓟[ty]1149{CompilerInterface})
{
 𝓛12549{$Switch}(𝓟334{format})
 𝓛12561{$Case}(𝓛8743{String})
 return 𝓟336 = 𝓟189{CONSTRUCTOR}(𝓟335{options})
 𝓛12561{$Case}(𝓛8743{String})
 return 𝓟336 = 𝓟307{CONSTRUCTOR}(𝓟335{options})
 𝓛12561{$Case}(𝓛8743{String})
 return 𝓟336 = 𝓟219{CONSTRUCTOR}(𝓟335{options})
 𝓛8749{Error}.CONSTRUCTOR(𝓛12554{$Template}(𝓟334{format}))
}
class 𝓟[ty]337{CompilerFactory}{
}

Module: src/cli/tasks/task.interface

type 𝓟[ty]1146{TaskInterface} = {execute: ()->𝓛[ty]10033{Void}}

Module: src/utils/translation.collection

type 𝓟[ty]1151{TranslationType} = {access: (𝓛[ty]10051{String})->𝓛[ty]10051{String}}
function 𝓟341{CONSTRUCTOR} (𝓟342{values}: [OOV]𝓟[ty]1151{TranslationType}): (𝓟[ty]346{TranslationCollection})
{
 const 𝓟[ty]346{TranslationCollection};
 const 𝓟[ty]346{TranslationCollection};
 𝓟[ty]346{TranslationCollection}.values ⟵ {};
 𝓟[ty]346{TranslationCollection}.values ⟵ 𝓟342{values};
}
class 𝓟[ty]346{TranslationCollection}{
 𝓟348{values}: [OOV]𝓟[ty]1151{TranslationType};
 function 𝓟403{count} (): (𝓟404: 𝓛[ty]8655{Number})
 {
 return 𝓟404 = 𝓛8741{Object}.keys(𝓟[ty]346{TranslationCollection}.values).length
 }
 function 𝓟381{union} (𝓟382{collection}: [OOV]𝓟[ty]346{TranslationCollection}): (𝓟383: [OOV]𝓟[ty]346{TranslationCollection})
 {
 return 𝓟383 = 𝓟341{CONSTRUCTOR}(𝓛8741{Object}.assign({},𝓟[ty]346{TranslationCollection}.values,𝓟382{collection}.values))
 }
 function 𝓟384{intersect} (𝓟385{collection}: [OOV]𝓟[ty]346{TranslationCollection}): (𝓟386: [OOV]𝓟[ty]346{TranslationCollection})
 {
 let 𝓟387{values}: [OOV]𝓟[ty]1151{TranslationType} = {};
 function 𝓟388{$Lambda24} (𝓟389{key}): (𝓟390: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟390 = 𝓟385{collection}.has(𝓟389{key})
 }
 function 𝓟391{$Lambda25} (𝓟392{key}: 𝓛[ty]10051{String},𝓟393{val}: 𝓛[ty]10051{String}): (𝓟394: [miss]𝓛[ty]10033{Void})
 {
 𝓟387{values}.access(𝓟392{key}) ⟵ 𝓟393{val};
 }
 𝓟[ty]346{TranslationCollection}.filter(𝓟388{$Lambda24}).forEach(𝓟391{$Lambda25})
 return 𝓟386 = 𝓟341{CONSTRUCTOR}(𝓟387{values})
 }
 function 𝓟395{has} (𝓟396{key}: 𝓛[ty]10051{String}): (𝓟397: 𝓛[ty]8666{Boolean})
 {
 return 𝓟397 = 𝓟[ty]346{TranslationCollection}.values.hasOwnProperty(𝓟396{key})
 }
 function 𝓟367{forEach} (𝓟368{callback}: 𝓛[ty]8696{Function}): (𝓟369: [OOV]𝓟[ty]346{TranslationCollection})
 {
 function 𝓟370{$Lambda22} (𝓟371{key}): (𝓟372: [OOV]any)
 {
 return 𝓟372 = 𝓟368{callback}.call(𝓟[ty]346{TranslationCollection},𝓟371{key},𝓟[ty]346{TranslationCollection}.values.access(𝓟371{key}))
 }
 𝓛8741{Object}.keys(𝓟[ty]346{TranslationCollection}.values).forEach(𝓟370{$Lambda22})
 return 𝓟369 = 𝓟[ty]346{TranslationCollection}
 }
 function 𝓟353{addKeys} (𝓟354{keys}: 𝓛[ty]8670{Array}): (𝓟355: [OOV]𝓟[ty]346{TranslationCollection})
 {
 function 𝓟356{$Lambda20} (𝓟357{results},𝓟358{key}): (𝓟359: [OOV]𝓟[ty]1151{TranslationType})
 {
 𝓟357{results}.access(𝓟358{key}) ⟵ 𝓛8743{String};
 return 𝓟359 = 𝓟357{results}
 }
 const 𝓟360{values}: [OOV]𝓟[ty]1151{TranslationType} = 𝓟354{keys}.reduce(𝓟356{$Lambda20},{} as 𝓟[ty]1151{TranslationType});
 return 𝓟355 = 𝓟341{CONSTRUCTOR}(𝓛8741{Object}.assign({},𝓟[ty]346{TranslationCollection}.values,𝓟360{values}))
 }
 function 𝓟373{filter} (𝓟374{callback}: 𝓛[ty]8696{Function}): (𝓟375: [OOV]𝓟[ty]346{TranslationCollection})
 {
 let 𝓟376{values}: [OOV]𝓟[ty]1151{TranslationType} = {};
 function 𝓟377{$Lambda23} (𝓟378{key}: 𝓛[ty]10051{String},𝓟379{val}: 𝓛[ty]10051{String}): (𝓟380: [miss]𝓛[ty]10033{Void})
 {
 if (𝓟374{callback}.call(𝓟[ty]346{TranslationCollection},𝓟378{key},𝓟379{val}))
 {
 𝓟376{values}.access(𝓟378{key}) ⟵ 𝓟379{val};
 }
 }
 𝓟[ty]346{TranslationCollection}.forEach(𝓟377{$Lambda23})
 return 𝓟375 = 𝓟341{CONSTRUCTOR}(𝓟376{values})
 }
 function 𝓟361{remove} (𝓟362{key}: 𝓛[ty]10051{String}): (𝓟363: [OOV]𝓟[ty]346{TranslationCollection})
 {
 function 𝓟364{$Lambda21} (𝓟365{k}): (𝓟366: [miss]𝓛[ty]8666{Boolean})
 {
 return 𝓟366 = 𝓟362{key}.ExclamationEqualsEqualsToken(𝓟365{k})
 }
 return 𝓟363 = 𝓟[ty]346{TranslationCollection}.filter(𝓟364{$Lambda21})
 }
 function 𝓟398{get} (𝓟399{key}: 𝓛[ty]10051{String}): (𝓟400: 𝓛[ty]10051{String})
 {
 return 𝓟400 = 𝓟[ty]346{TranslationCollection}.values.access(𝓟399{key})
 }
 function 𝓟407{sort} (𝓟408{compareFn}: 𝓛[ty]8696{Function}): (𝓟409: [OOV]𝓟[ty]346{TranslationCollection})
 {
 let 𝓟410{values}: [OOV]𝓟[ty]1151{TranslationType} = {};
 function 𝓟411{$Lambda26} (𝓟412{key}): (𝓟413: [miss]𝓛[ty]10033{Void})
 {
 𝓟410{values}.access(𝓟412{key}) ⟵ 𝓟[ty]346{TranslationCollection}.get(𝓟412{key});
 }
 𝓟[ty]346{TranslationCollection}.keys().sort(𝓟408{compareFn}).forEach(𝓟411{$Lambda26})
 return 𝓟409 = 𝓟341{CONSTRUCTOR}(𝓟410{values})
 }
 function 𝓟405{isEmpty} (): (𝓟406: 𝓛[ty]8666{Boolean})
 {
 return 𝓟406 = 𝓛8741{Object}.keys(𝓟[ty]346{TranslationCollection}.values).length.EqualsEqualsEqualsToken(𝓛8745{Number})
 }
 function 𝓟349{add} (𝓟350{key}: 𝓛[ty]10051{String},𝓟351{val}: 𝓛[ty]10051{String}): (𝓟352: [OOV]𝓟[ty]346{TranslationCollection})
 {
 return 𝓟352 = 𝓟341{CONSTRUCTOR}(𝓛8741{Object}.assign({},𝓟[ty]346{TranslationCollection}.values,{[key]: 𝓟351{val}}))
 }
 function 𝓟401{keys} (): (𝓟402: (𝓛[ty]8655{Number} ≠ 𝓛[ty]8670{Array}))
 {
 return 𝓟402 = 𝓛8741{Object}.keys(𝓟[ty]346{TranslationCollection}.values)
 }
}