@angular/compiler-cli 12.1.0-next.6 → 12.1.3

package/src/ngtsc/typecheck/src/type_check_file.mjs

@@ -1,65 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import * as ts from 'typescript';
-import { join } from '../../file_system';
-import { NoopImportRewriter } from '../../imports';
-import { ImportManager } from '../../translator';
-import { Environment } from './environment';
-import { generateTypeCheckBlock } from './type_check_block';
-/**
- * An `Environment` representing the single type-checking file into which most (if not all) Type
- * Check Blocks (TCBs) will be generated.
- *
- * The `TypeCheckFile` hosts multiple TCBs and allows the sharing of declarations (e.g. type
- * constructors) between them. Rather than return such declarations via `getPreludeStatements()`, it
- * hoists them to the top of the generated `ts.SourceFile`.
- */
-export class TypeCheckFile extends Environment {
-    constructor(fileName, config, refEmitter, reflector, compilerHost) {
-        super(config, new ImportManager(new NoopImportRewriter(), 'i'), refEmitter, reflector, ts.createSourceFile(compilerHost.getCanonicalFileName(fileName), '', ts.ScriptTarget.Latest, true));
-        this.fileName = fileName;
-        this.nextTcbId = 1;
-        this.tcbStatements = [];
-    }
-    addTypeCheckBlock(ref, meta, domSchemaChecker, oobRecorder, genericContextBehavior) {
-        const fnId = ts.createIdentifier(`_tcb${this.nextTcbId++}`);
-        const fn = generateTypeCheckBlock(this, ref, fnId, meta, domSchemaChecker, oobRecorder, genericContextBehavior);
-        this.tcbStatements.push(fn);
-    }
-    render(removeComments) {
-        let source = this.importManager.getAllImports(this.contextFile.fileName)
-            .map(i => `import * as ${i.qualifier.text} from '${i.specifier}';`)
-            .join('\n') +
-            '\n\n';
-        const printer = ts.createPrinter({ removeComments });
-        source += '\n';
-        for (const stmt of this.pipeInstStatements) {
-            source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\n';
-        }
-        for (const stmt of this.typeCtorStatements) {
-            source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\n';
-        }
-        source += '\n';
-        for (const stmt of this.tcbStatements) {
-            source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\n';
-        }
-        // Ensure the template type-checking file is an ES module. Otherwise, it's interpreted as some
-        // kind of global namespace in TS, which forces a full re-typecheck of the user's program that
-        // is somehow more expensive than the initial parse.
-        source += '\nexport const IS_A_MODULE = true;\n';
-        return source;
-    }
-    getPreludeStatements() {
-        return [];
-    }
-}
-export function typeCheckFilePath(rootDirs) {
-    const shortest = rootDirs.concat([]).sort((a, b) => a.length - b.length)[0];
-    return join(shortest, '__ng_typecheck__.ts');
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type_check_file.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/type_check_file.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\n\nimport {AbsoluteFsPath, join} from '../../file_system';\nimport {NoopImportRewriter, Reference, ReferenceEmitter} from '../../imports';\nimport {ClassDeclaration, ReflectionHost} from '../../reflection';\nimport {ImportManager} from '../../translator';\nimport {TypeCheckBlockMetadata, TypeCheckingConfig} from '../api';\n\nimport {DomSchemaChecker} from './dom';\nimport {Environment} from './environment';\nimport {OutOfBandDiagnosticRecorder} from './oob';\nimport {generateTypeCheckBlock, TcbGenericContextBehavior} from './type_check_block';\n\n\n\n/**\n * An `Environment` representing the single type-checking file into which most (if not all) Type\n * Check Blocks (TCBs) will be generated.\n *\n * The `TypeCheckFile` hosts multiple TCBs and allows the sharing of declarations (e.g. type\n * constructors) between them. Rather than return such declarations via `getPreludeStatements()`, it\n * hoists them to the top of the generated `ts.SourceFile`.\n */\nexport class TypeCheckFile extends Environment {\n  private nextTcbId = 1;\n  private tcbStatements: ts.Statement[] = [];\n\n  constructor(\n      readonly fileName: AbsoluteFsPath, config: TypeCheckingConfig, refEmitter: ReferenceEmitter,\n      reflector: ReflectionHost, compilerHost: Pick<ts.CompilerHost, 'getCanonicalFileName'>) {\n    super(\n        config, new ImportManager(new NoopImportRewriter(), 'i'), refEmitter, reflector,\n        ts.createSourceFile(\n            compilerHost.getCanonicalFileName(fileName), '', ts.ScriptTarget.Latest, true));\n  }\n\n  addTypeCheckBlock(\n      ref: Reference<ClassDeclaration<ts.ClassDeclaration>>, meta: TypeCheckBlockMetadata,\n      domSchemaChecker: DomSchemaChecker, oobRecorder: OutOfBandDiagnosticRecorder,\n      genericContextBehavior: TcbGenericContextBehavior): void {\n    const fnId = ts.createIdentifier(`_tcb${this.nextTcbId++}`);\n    const fn = generateTypeCheckBlock(\n        this, ref, fnId, meta, domSchemaChecker, oobRecorder, genericContextBehavior);\n    this.tcbStatements.push(fn);\n  }\n\n  render(removeComments: boolean): string {\n    let source: string = this.importManager.getAllImports(this.contextFile.fileName)\n                             .map(i => `import * as ${i.qualifier.text} from '${i.specifier}';`)\n                             .join('\\n') +\n        '\\n\\n';\n    const printer = ts.createPrinter({removeComments});\n    source += '\\n';\n    for (const stmt of this.pipeInstStatements) {\n      source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\\n';\n    }\n    for (const stmt of this.typeCtorStatements) {\n      source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\\n';\n    }\n    source += '\\n';\n    for (const stmt of this.tcbStatements) {\n      source += printer.printNode(ts.EmitHint.Unspecified, stmt, this.contextFile) + '\\n';\n    }\n\n    // Ensure the template type-checking file is an ES module. Otherwise, it's interpreted as some\n    // kind of global namespace in TS, which forces a full re-typecheck of the user's program that\n    // is somehow more expensive than the initial parse.\n    source += '\\nexport const IS_A_MODULE = true;\\n';\n\n    return source;\n  }\n\n  getPreludeStatements(): ts.Statement[] {\n    return [];\n  }\n}\n\nexport function typeCheckFilePath(rootDirs: AbsoluteFsPath[]): AbsoluteFsPath {\n  const shortest = rootDirs.concat([]).sort((a, b) => a.length - b.length)[0];\n  return join(shortest, '__ng_typecheck__.ts');\n}\n"]}

package/src/ngtsc/typecheck/src/type_constructor.mjs

@@ -1,227 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import * as ts from 'typescript';
-import { checkIfGenericTypeBoundsAreContextFree } from './tcb_util';
-import { tsCreateTypeQueryForCoercedInput } from './ts_util';
-export function generateTypeCtorDeclarationFn(node, meta, nodeTypeRef, typeParams, reflector) {
-    if (requiresInlineTypeCtor(node, reflector)) {
-        throw new Error(`${node.name.text} requires an inline type constructor`);
-    }
-    const rawTypeArgs = typeParams !== undefined ? generateGenericArgs(typeParams) : undefined;
-    const rawType = ts.createTypeReferenceNode(nodeTypeRef, rawTypeArgs);
-    const initParam = constructTypeCtorParameter(node, meta, rawType);
-    const typeParameters = typeParametersWithDefaultTypes(typeParams);
-    if (meta.body) {
-        const fnType = ts.createFunctionTypeNode(
-        /* typeParameters */ typeParameters, 
-        /* parameters */ [initParam], 
-        /* type */ rawType);
-        const decl = ts.createVariableDeclaration(
-        /* name */ meta.fnName, 
-        /* type */ fnType, 
-        /* body */ ts.createNonNullExpression(ts.createNull()));
-        const declList = ts.createVariableDeclarationList([decl], ts.NodeFlags.Const);
-        return ts.createVariableStatement(
-        /* modifiers */ undefined, 
-        /* declarationList */ declList);
-    }
-    else {
-        return ts.createFunctionDeclaration(
-        /* decorators */ undefined, 
-        /* modifiers */ [ts.createModifier(ts.SyntaxKind.DeclareKeyword)], 
-        /* asteriskToken */ undefined, 
-        /* name */ meta.fnName, 
-        /* typeParameters */ typeParameters, 
-        /* parameters */ [initParam], 
-        /* type */ rawType, 
-        /* body */ undefined);
-    }
-}
-/**
- * Generate an inline type constructor for the given class and metadata.
- *
- * An inline type constructor is a specially shaped TypeScript static method, intended to be placed
- * within a directive class itself, that permits type inference of any generic type parameters of
- * the class from the types of expressions bound to inputs or outputs, and the types of elements
- * that match queries performed by the directive. It also catches any errors in the types of these
- * expressions. This method is never called at runtime, but is used in type-check blocks to
- * construct directive types.
- *
- * An inline type constructor for NgFor looks like:
- *
- * static ngTypeCtor<T>(init: Pick<NgForOf<T>, 'ngForOf'|'ngForTrackBy'|'ngForTemplate'>):
- *   NgForOf<T>;
- *
- * A typical constructor would be:
- *
- * NgForOf.ngTypeCtor(init: {
- *   ngForOf: ['foo', 'bar'],
- *   ngForTrackBy: null as any,
- *   ngForTemplate: null as any,
- * }); // Infers a type of NgForOf<string>.
- *
- * Any inputs declared on the type for which no property binding is present are assigned a value of
- * type `any`, to avoid producing any type errors for unset inputs.
- *
- * Inline type constructors are used when the type being created has bounded generic types which
- * make writing a declared type constructor (via `generateTypeCtorDeclarationFn`) difficult or
- * impossible.
- *
- * @param node the `ClassDeclaration<ts.ClassDeclaration>` for which a type constructor will be
- * generated.
- * @param meta additional metadata required to generate the type constructor.
- * @returns a `ts.MethodDeclaration` for the type constructor.
- */
-export function generateInlineTypeCtor(node, meta) {
-    // Build rawType, a `ts.TypeNode` of the class with its generic parameters passed through from
-    // the definition without any type bounds. For example, if the class is
-    // `FooDirective<T extends Bar>`, its rawType would be `FooDirective<T>`.
-    const rawTypeArgs = node.typeParameters !== undefined ? generateGenericArgs(node.typeParameters) : undefined;
-    const rawType = ts.createTypeReferenceNode(node.name, rawTypeArgs);
-    const initParam = constructTypeCtorParameter(node, meta, rawType);
-    // If this constructor is being generated into a .ts file, then it needs a fake body. The body
-    // is set to a return of `null!`. If the type constructor is being generated into a .d.ts file,
-    // it needs no body.
-    let body = undefined;
-    if (meta.body) {
-        body = ts.createBlock([
-            ts.createReturn(ts.createNonNullExpression(ts.createNull())),
-        ]);
-    }
-    // Create the type constructor method declaration.
-    return ts.createMethod(
-    /* decorators */ undefined, 
-    /* modifiers */ [ts.createModifier(ts.SyntaxKind.StaticKeyword)], 
-    /* asteriskToken */ undefined, 
-    /* name */ meta.fnName, 
-    /* questionToken */ undefined, 
-    /* typeParameters */ typeParametersWithDefaultTypes(node.typeParameters), 
-    /* parameters */ [initParam], 
-    /* type */ rawType, 
-    /* body */ body);
-}
-function constructTypeCtorParameter(node, meta, rawType) {
-    // initType is the type of 'init', the single argument to the type constructor method.
-    // If the Directive has any inputs, its initType will be:
-    //
-    // Pick<rawType, 'inputA'|'inputB'>
-    //
-    // Pick here is used to select only those fields from which the generic type parameters of the
-    // directive will be inferred.
-    //
-    // In the special case there are no inputs, initType is set to {}.
-    let initType = null;
-    const keys = meta.fields.inputs;
-    const plainKeys = [];
-    const coercedKeys = [];
-    for (const key of keys) {
-        if (!meta.coercedInputFields.has(key)) {
-            plainKeys.push(ts.createLiteralTypeNode(ts.createStringLiteral(key)));
-        }
-        else {
-            coercedKeys.push(ts.createPropertySignature(
-            /* modifiers */ undefined, 
-            /* name */ key, 
-            /* questionToken */ undefined, 
-            /* type */ tsCreateTypeQueryForCoercedInput(rawType.typeName, key), 
-            /* initializer */ undefined));
-        }
-    }
-    if (plainKeys.length > 0) {
-        // Construct a union of all the field names.
-        const keyTypeUnion = ts.createUnionTypeNode(plainKeys);
-        // Construct the Pick<rawType, keyTypeUnion>.
-        initType = ts.createTypeReferenceNode('Pick', [rawType, keyTypeUnion]);
-    }
-    if (coercedKeys.length > 0) {
-        const coercedLiteral = ts.createTypeLiteralNode(coercedKeys);
-        initType = initType !== null ? ts.createIntersectionTypeNode([initType, coercedLiteral]) :
-            coercedLiteral;
-    }
-    if (initType === null) {
-        // Special case - no inputs, outputs, or other fields which could influence the result type.
-        initType = ts.createTypeLiteralNode([]);
-    }
-    // Create the 'init' parameter itself.
-    return ts.createParameter(
-    /* decorators */ undefined, 
-    /* modifiers */ undefined, 
-    /* dotDotDotToken */ undefined, 
-    /* name */ 'init', 
-    /* questionToken */ undefined, 
-    /* type */ initType, 
-    /* initializer */ undefined);
-}
-function generateGenericArgs(params) {
-    return params.map(param => ts.createTypeReferenceNode(param.name, undefined));
-}
-export function requiresInlineTypeCtor(node, host) {
-    // The class requires an inline type constructor if it has generic type bounds that can not be
-    // emitted into a different context.
-    return !checkIfGenericTypeBoundsAreContextFree(node, host);
-}
-/**
- * Add a default `= any` to type parameters that don't have a default value already.
- *
- * TypeScript uses the default type of a type parameter whenever inference of that parameter fails.
- * This can happen when inferring a complex type from 'any'. For example, if `NgFor`'s inference is
- * done with the TCB code:
- *
- * ```
- * class NgFor<T> {
- *   ngForOf: T[];
- * }
- *
- * declare function ctor<T>(o: Pick<NgFor<T>, 'ngForOf'|'ngForTrackBy'|'ngForTemplate'>): NgFor<T>;
- * ```
- *
- * An invocation looks like:
- *
- * ```
- * var _t1 = ctor({ngForOf: [1, 2], ngForTrackBy: null as any, ngForTemplate: null as any});
- * ```
- *
- * This correctly infers the type `NgFor<number>` for `_t1`, since `T` is inferred from the
- * assignment of type `number[]` to `ngForOf`'s type `T[]`. However, if `any` is passed instead:
- *
- * ```
- * var _t2 = ctor({ngForOf: [1, 2] as any, ngForTrackBy: null as any, ngForTemplate: null as any});
- * ```
- *
- * then inference for `T` fails (it cannot be inferred from `T[] = any`). In this case, `T` takes
- * the type `{}`, and so `_t2` is inferred as `NgFor<{}>`. This is obviously wrong.
- *
- * Adding a default type to the generic declaration in the constructor solves this problem, as the
- * default type will be used in the event that inference fails.
- *
- * ```
- * declare function ctor<T = any>(o: Pick<NgFor<T>, 'ngForOf'>): NgFor<T>;
- *
- * var _t3 = ctor({ngForOf: [1, 2] as any});
- * ```
- *
- * This correctly infers `T` as `any`, and therefore `_t3` as `NgFor<any>`.
- */
-function typeParametersWithDefaultTypes(params) {
-    if (params === undefined) {
-        return undefined;
-    }
-    return params.map(param => {
-        if (param.default === undefined) {
-            return ts.updateTypeParameterDeclaration(
-            /* node */ param, 
-            /* name */ param.name, 
-            /* constraint */ param.constraint, 
-            /* defaultType */ ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword));
-        }
-        else {
-            return param;
-        }
-    });
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type_constructor.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/type_constructor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport * as ts from 'typescript';\n\nimport {ClassDeclaration, ReflectionHost} from '../../reflection';\nimport {TypeCtorMetadata} from '../api';\nimport {checkIfGenericTypeBoundsAreContextFree} from './tcb_util';\n\nimport {tsCreateTypeQueryForCoercedInput} from './ts_util';\n\nexport function generateTypeCtorDeclarationFn(\n    node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata, nodeTypeRef: ts.EntityName,\n    typeParams: ts.TypeParameterDeclaration[]|undefined, reflector: ReflectionHost): ts.Statement {\n  if (requiresInlineTypeCtor(node, reflector)) {\n    throw new Error(`${node.name.text} requires an inline type constructor`);\n  }\n\n  const rawTypeArgs = typeParams !== undefined ? generateGenericArgs(typeParams) : undefined;\n  const rawType = ts.createTypeReferenceNode(nodeTypeRef, rawTypeArgs);\n\n  const initParam = constructTypeCtorParameter(node, meta, rawType);\n\n  const typeParameters = typeParametersWithDefaultTypes(typeParams);\n\n  if (meta.body) {\n    const fnType = ts.createFunctionTypeNode(\n        /* typeParameters */ typeParameters,\n        /* parameters */[initParam],\n        /* type */ rawType,\n    );\n\n    const decl = ts.createVariableDeclaration(\n        /* name */ meta.fnName,\n        /* type */ fnType,\n        /* body */ ts.createNonNullExpression(ts.createNull()));\n    const declList = ts.createVariableDeclarationList([decl], ts.NodeFlags.Const);\n    return ts.createVariableStatement(\n        /* modifiers */ undefined,\n        /* declarationList */ declList);\n  } else {\n    return ts.createFunctionDeclaration(\n        /* decorators */ undefined,\n        /* modifiers */[ts.createModifier(ts.SyntaxKind.DeclareKeyword)],\n        /* asteriskToken */ undefined,\n        /* name */ meta.fnName,\n        /* typeParameters */ typeParameters,\n        /* parameters */[initParam],\n        /* type */ rawType,\n        /* body */ undefined);\n  }\n}\n\n/**\n * Generate an inline type constructor for the given class and metadata.\n *\n * An inline type constructor is a specially shaped TypeScript static method, intended to be placed\n * within a directive class itself, that permits type inference of any generic type parameters of\n * the class from the types of expressions bound to inputs or outputs, and the types of elements\n * that match queries performed by the directive. It also catches any errors in the types of these\n * expressions. This method is never called at runtime, but is used in type-check blocks to\n * construct directive types.\n *\n * An inline type constructor for NgFor looks like:\n *\n * static ngTypeCtor<T>(init: Pick<NgForOf<T>, 'ngForOf'|'ngForTrackBy'|'ngForTemplate'>):\n *   NgForOf<T>;\n *\n * A typical constructor would be:\n *\n * NgForOf.ngTypeCtor(init: {\n *   ngForOf: ['foo', 'bar'],\n *   ngForTrackBy: null as any,\n *   ngForTemplate: null as any,\n * }); // Infers a type of NgForOf<string>.\n *\n * Any inputs declared on the type for which no property binding is present are assigned a value of\n * type `any`, to avoid producing any type errors for unset inputs.\n *\n * Inline type constructors are used when the type being created has bounded generic types which\n * make writing a declared type constructor (via `generateTypeCtorDeclarationFn`) difficult or\n * impossible.\n *\n * @param node the `ClassDeclaration<ts.ClassDeclaration>` for which a type constructor will be\n * generated.\n * @param meta additional metadata required to generate the type constructor.\n * @returns a `ts.MethodDeclaration` for the type constructor.\n */\nexport function generateInlineTypeCtor(\n    node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata): ts.MethodDeclaration {\n  // Build rawType, a `ts.TypeNode` of the class with its generic parameters passed through from\n  // the definition without any type bounds. For example, if the class is\n  // `FooDirective<T extends Bar>`, its rawType would be `FooDirective<T>`.\n  const rawTypeArgs =\n      node.typeParameters !== undefined ? generateGenericArgs(node.typeParameters) : undefined;\n  const rawType = ts.createTypeReferenceNode(node.name, rawTypeArgs);\n\n  const initParam = constructTypeCtorParameter(node, meta, rawType);\n\n  // If this constructor is being generated into a .ts file, then it needs a fake body. The body\n  // is set to a return of `null!`. If the type constructor is being generated into a .d.ts file,\n  // it needs no body.\n  let body: ts.Block|undefined = undefined;\n  if (meta.body) {\n    body = ts.createBlock([\n      ts.createReturn(ts.createNonNullExpression(ts.createNull())),\n    ]);\n  }\n\n  // Create the type constructor method declaration.\n  return ts.createMethod(\n      /* decorators */ undefined,\n      /* modifiers */[ts.createModifier(ts.SyntaxKind.StaticKeyword)],\n      /* asteriskToken */ undefined,\n      /* name */ meta.fnName,\n      /* questionToken */ undefined,\n      /* typeParameters */ typeParametersWithDefaultTypes(node.typeParameters),\n      /* parameters */[initParam],\n      /* type */ rawType,\n      /* body */ body,\n  );\n}\n\nfunction constructTypeCtorParameter(\n    node: ClassDeclaration<ts.ClassDeclaration>, meta: TypeCtorMetadata,\n    rawType: ts.TypeReferenceNode): ts.ParameterDeclaration {\n  // initType is the type of 'init', the single argument to the type constructor method.\n  // If the Directive has any inputs, its initType will be:\n  //\n  // Pick<rawType, 'inputA'|'inputB'>\n  //\n  // Pick here is used to select only those fields from which the generic type parameters of the\n  // directive will be inferred.\n  //\n  // In the special case there are no inputs, initType is set to {}.\n  let initType: ts.TypeNode|null = null;\n\n  const keys: string[] = meta.fields.inputs;\n  const plainKeys: ts.LiteralTypeNode[] = [];\n  const coercedKeys: ts.PropertySignature[] = [];\n  for (const key of keys) {\n    if (!meta.coercedInputFields.has(key)) {\n      plainKeys.push(ts.createLiteralTypeNode(ts.createStringLiteral(key)));\n    } else {\n      coercedKeys.push(ts.createPropertySignature(\n          /* modifiers */ undefined,\n          /* name */ key,\n          /* questionToken */ undefined,\n          /* type */ tsCreateTypeQueryForCoercedInput(rawType.typeName, key),\n          /* initializer */ undefined));\n    }\n  }\n  if (plainKeys.length > 0) {\n    // Construct a union of all the field names.\n    const keyTypeUnion = ts.createUnionTypeNode(plainKeys);\n\n    // Construct the Pick<rawType, keyTypeUnion>.\n    initType = ts.createTypeReferenceNode('Pick', [rawType, keyTypeUnion]);\n  }\n  if (coercedKeys.length > 0) {\n    const coercedLiteral = ts.createTypeLiteralNode(coercedKeys);\n\n    initType = initType !== null ? ts.createIntersectionTypeNode([initType, coercedLiteral]) :\n                                   coercedLiteral;\n  }\n\n  if (initType === null) {\n    // Special case - no inputs, outputs, or other fields which could influence the result type.\n    initType = ts.createTypeLiteralNode([]);\n  }\n\n  // Create the 'init' parameter itself.\n  return ts.createParameter(\n      /* decorators */ undefined,\n      /* modifiers */ undefined,\n      /* dotDotDotToken */ undefined,\n      /* name */ 'init',\n      /* questionToken */ undefined,\n      /* type */ initType,\n      /* initializer */ undefined);\n}\n\nfunction generateGenericArgs(params: ReadonlyArray<ts.TypeParameterDeclaration>): ts.TypeNode[] {\n  return params.map(param => ts.createTypeReferenceNode(param.name, undefined));\n}\n\nexport function requiresInlineTypeCtor(\n    node: ClassDeclaration<ts.ClassDeclaration>, host: ReflectionHost): boolean {\n  // The class requires an inline type constructor if it has generic type bounds that can not be\n  // emitted into a different context.\n  return !checkIfGenericTypeBoundsAreContextFree(node, host);\n}\n\n/**\n * Add a default `= any` to type parameters that don't have a default value already.\n *\n * TypeScript uses the default type of a type parameter whenever inference of that parameter fails.\n * This can happen when inferring a complex type from 'any'. For example, if `NgFor`'s inference is\n * done with the TCB code:\n *\n * ```\n * class NgFor<T> {\n *   ngForOf: T[];\n * }\n *\n * declare function ctor<T>(o: Pick<NgFor<T>, 'ngForOf'|'ngForTrackBy'|'ngForTemplate'>): NgFor<T>;\n * ```\n *\n * An invocation looks like:\n *\n * ```\n * var _t1 = ctor({ngForOf: [1, 2], ngForTrackBy: null as any, ngForTemplate: null as any});\n * ```\n *\n * This correctly infers the type `NgFor<number>` for `_t1`, since `T` is inferred from the\n * assignment of type `number[]` to `ngForOf`'s type `T[]`. However, if `any` is passed instead:\n *\n * ```\n * var _t2 = ctor({ngForOf: [1, 2] as any, ngForTrackBy: null as any, ngForTemplate: null as any});\n * ```\n *\n * then inference for `T` fails (it cannot be inferred from `T[] = any`). In this case, `T` takes\n * the type `{}`, and so `_t2` is inferred as `NgFor<{}>`. This is obviously wrong.\n *\n * Adding a default type to the generic declaration in the constructor solves this problem, as the\n * default type will be used in the event that inference fails.\n *\n * ```\n * declare function ctor<T = any>(o: Pick<NgFor<T>, 'ngForOf'>): NgFor<T>;\n *\n * var _t3 = ctor({ngForOf: [1, 2] as any});\n * ```\n *\n * This correctly infers `T` as `any`, and therefore `_t3` as `NgFor<any>`.\n */\nfunction typeParametersWithDefaultTypes(params: ReadonlyArray<ts.TypeParameterDeclaration>|\n                                        undefined): ts.TypeParameterDeclaration[]|undefined {\n  if (params === undefined) {\n    return undefined;\n  }\n\n  return params.map(param => {\n    if (param.default === undefined) {\n      return ts.updateTypeParameterDeclaration(\n          /* node */ param,\n          /* name */ param.name,\n          /* constraint */ param.constraint,\n          /* defaultType */ ts.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword));\n    } else {\n      return param;\n    }\n  });\n}\n"]}

package/src/ngtsc/typecheck/src/type_emitter.mjs

@@ -1,140 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import * as ts from 'typescript';
-import { Reference } from '../../imports';
-/**
- * Determines whether the provided type can be emitted, which means that it can be safely emitted
- * into a different location.
- *
- * If this function returns true, a `TypeEmitter` should be able to succeed. Vice versa, if this
- * function returns false, then using the `TypeEmitter` should not be attempted as it is known to
- * fail.
- */
-export function canEmitType(type, resolver) {
-    return canEmitTypeWorker(type);
-    function canEmitTypeWorker(type) {
-        return visitTypeNode(type, {
-            visitTypeReferenceNode: type => canEmitTypeReference(type),
-            visitArrayTypeNode: type => canEmitTypeWorker(type.elementType),
-            visitKeywordType: () => true,
-            visitLiteralType: () => true,
-            visitOtherType: () => false,
-        });
-    }
-    function canEmitTypeReference(type) {
-        const reference = resolver(type);
-        // If the type could not be resolved, it can not be emitted.
-        if (reference === null) {
-            return false;
-        }
-        // If the type is a reference without a owning module, consider the type not to be eligible for
-        // emitting.
-        if (reference instanceof Reference && !reference.hasOwningModuleGuess) {
-            return false;
-        }
-        // The type can be emitted if either it does not have any type arguments, or all of them can be
-        // emitted.
-        return type.typeArguments === undefined || type.typeArguments.every(canEmitTypeWorker);
-    }
-}
-/**
- * Given a `ts.TypeNode`, this class derives an equivalent `ts.TypeNode` that has been emitted into
- * a different context.
- *
- * For example, consider the following code:
- *
- * ```
- * import {NgIterable} from '@angular/core';
- *
- * class NgForOf<T, U extends NgIterable<T>> {}
- * ```
- *
- * Here, the generic type parameters `T` and `U` can be emitted into a different context, as the
- * type reference to `NgIterable` originates from an absolute module import so that it can be
- * emitted anywhere, using that same module import. The process of emitting translates the
- * `NgIterable` type reference to a type reference that is valid in the context in which it is
- * emitted, for example:
- *
- * ```
- * import * as i0 from '@angular/core';
- * import * as i1 from '@angular/common';
- *
- * const _ctor1: <T, U extends i0.NgIterable<T>>(o: Pick<i1.NgForOf<T, U>, 'ngForOf'>):
- * i1.NgForOf<T, U>;
- * ```
- *
- * Notice how the type reference for `NgIterable` has been translated into a qualified name,
- * referring to the namespace import that was created.
- */
-export class TypeEmitter {
-    constructor(resolver, emitReference) {
-        this.resolver = resolver;
-        this.emitReference = emitReference;
-    }
-    emitType(type) {
-        return visitTypeNode(type, {
-            visitTypeReferenceNode: type => this.emitTypeReference(type),
-            visitArrayTypeNode: type => ts.updateArrayTypeNode(type, this.emitType(type.elementType)),
-            visitKeywordType: type => type,
-            visitLiteralType: type => type,
-            visitOtherType: () => {
-                throw new Error('Unable to emit a complex type');
-            },
-        });
-    }
-    emitTypeReference(type) {
-        // Determine the reference that the type corresponds with.
-        const reference = this.resolver(type);
-        if (reference === null) {
-            throw new Error('Unable to emit an unresolved reference');
-        }
-        // Emit the type arguments, if any.
-        let typeArguments = undefined;
-        if (type.typeArguments !== undefined) {
-            typeArguments = ts.createNodeArray(type.typeArguments.map(typeArg => this.emitType(typeArg)));
-        }
-        // Emit the type name.
-        let typeName = type.typeName;
-        if (reference instanceof Reference) {
-            if (!reference.hasOwningModuleGuess) {
-                throw new Error('A type reference to emit must be imported from an absolute module');
-            }
-            const emittedType = this.emitReference(reference);
-            if (!ts.isTypeReferenceNode(emittedType)) {
-                throw new Error(`Expected TypeReferenceNode for emitted reference, got ${ts.SyntaxKind[emittedType.kind]}`);
-            }
-            typeName = emittedType.typeName;
-        }
-        return ts.updateTypeReferenceNode(type, typeName, typeArguments);
-    }
-}
-function visitTypeNode(type, visitor) {
-    if (ts.isTypeReferenceNode(type)) {
-        return visitor.visitTypeReferenceNode(type);
-    }
-    else if (ts.isArrayTypeNode(type)) {
-        return visitor.visitArrayTypeNode(type);
-    }
-    else if (ts.isLiteralTypeNode(type)) {
-        return visitor.visitLiteralType(type);
-    }
-    switch (type.kind) {
-        case ts.SyntaxKind.AnyKeyword:
-        case ts.SyntaxKind.UnknownKeyword:
-        case ts.SyntaxKind.NumberKeyword:
-        case ts.SyntaxKind.ObjectKeyword:
-        case ts.SyntaxKind.BooleanKeyword:
-        case ts.SyntaxKind.StringKeyword:
-        case ts.SyntaxKind.UndefinedKeyword:
-        case ts.SyntaxKind.NullKeyword:
-            return visitor.visitKeywordType(type);
-        default:
-            return visitor.visitOtherType(type);
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type_emitter.js","sourceRoot":"","sources":["../../../../../../../../../packages/compiler-cli/src/ngtsc/typecheck/src/type_emitter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport * as ts from 'typescript';\nimport {Reference} from '../../imports';\n\n/**\n * A resolved type reference can either be a `Reference`, the original `ts.TypeReferenceNode` itself\n * or null to indicate the no reference could be resolved.\n */\nexport type ResolvedTypeReference = Reference|ts.TypeReferenceNode|null;\n\n/**\n * A type reference resolver function is responsible for finding the declaration of the type\n * reference and verifying whether it can be emitted.\n */\nexport type TypeReferenceResolver = (type: ts.TypeReferenceNode) => ResolvedTypeReference;\n\n/**\n * Determines whether the provided type can be emitted, which means that it can be safely emitted\n * into a different location.\n *\n * If this function returns true, a `TypeEmitter` should be able to succeed. Vice versa, if this\n * function returns false, then using the `TypeEmitter` should not be attempted as it is known to\n * fail.\n */\nexport function canEmitType(type: ts.TypeNode, resolver: TypeReferenceResolver): boolean {\n  return canEmitTypeWorker(type);\n\n  function canEmitTypeWorker(type: ts.TypeNode): boolean {\n    return visitTypeNode(type, {\n      visitTypeReferenceNode: type => canEmitTypeReference(type),\n      visitArrayTypeNode: type => canEmitTypeWorker(type.elementType),\n      visitKeywordType: () => true,\n      visitLiteralType: () => true,\n      visitOtherType: () => false,\n    });\n  }\n\n  function canEmitTypeReference(type: ts.TypeReferenceNode): boolean {\n    const reference = resolver(type);\n\n    // If the type could not be resolved, it can not be emitted.\n    if (reference === null) {\n      return false;\n    }\n\n    // If the type is a reference without a owning module, consider the type not to be eligible for\n    // emitting.\n    if (reference instanceof Reference && !reference.hasOwningModuleGuess) {\n      return false;\n    }\n\n    // The type can be emitted if either it does not have any type arguments, or all of them can be\n    // emitted.\n    return type.typeArguments === undefined || type.typeArguments.every(canEmitTypeWorker);\n  }\n}\n\n/**\n * Given a `ts.TypeNode`, this class derives an equivalent `ts.TypeNode` that has been emitted into\n * a different context.\n *\n * For example, consider the following code:\n *\n * ```\n * import {NgIterable} from '@angular/core';\n *\n * class NgForOf<T, U extends NgIterable<T>> {}\n * ```\n *\n * Here, the generic type parameters `T` and `U` can be emitted into a different context, as the\n * type reference to `NgIterable` originates from an absolute module import so that it can be\n * emitted anywhere, using that same module import. The process of emitting translates the\n * `NgIterable` type reference to a type reference that is valid in the context in which it is\n * emitted, for example:\n *\n * ```\n * import * as i0 from '@angular/core';\n * import * as i1 from '@angular/common';\n *\n * const _ctor1: <T, U extends i0.NgIterable<T>>(o: Pick<i1.NgForOf<T, U>, 'ngForOf'>):\n * i1.NgForOf<T, U>;\n * ```\n *\n * Notice how the type reference for `NgIterable` has been translated into a qualified name,\n * referring to the namespace import that was created.\n */\nexport class TypeEmitter {\n  /**\n   * Resolver function that computes a `Reference` corresponding with a `ts.TypeReferenceNode`.\n   */\n  private resolver: TypeReferenceResolver;\n\n  /**\n   * Given a `Reference`, this function is responsible for the actual emitting work. It should\n   * produce a `ts.TypeNode` that is valid within the desired context.\n   */\n  private emitReference: (ref: Reference) => ts.TypeNode;\n\n  constructor(resolver: TypeReferenceResolver, emitReference: (ref: Reference) => ts.TypeNode) {\n    this.resolver = resolver;\n    this.emitReference = emitReference;\n  }\n\n  emitType(type: ts.TypeNode): ts.TypeNode {\n    return visitTypeNode(type, {\n      visitTypeReferenceNode: type => this.emitTypeReference(type),\n      visitArrayTypeNode: type => ts.updateArrayTypeNode(type, this.emitType(type.elementType)),\n      visitKeywordType: type => type,\n      visitLiteralType: type => type,\n      visitOtherType: () => {\n        throw new Error('Unable to emit a complex type');\n      },\n    });\n  }\n\n  private emitTypeReference(type: ts.TypeReferenceNode): ts.TypeNode {\n    // Determine the reference that the type corresponds with.\n    const reference = this.resolver(type);\n    if (reference === null) {\n      throw new Error('Unable to emit an unresolved reference');\n    }\n\n    // Emit the type arguments, if any.\n    let typeArguments: ts.NodeArray<ts.TypeNode>|undefined = undefined;\n    if (type.typeArguments !== undefined) {\n      typeArguments = ts.createNodeArray(type.typeArguments.map(typeArg => this.emitType(typeArg)));\n    }\n\n    // Emit the type name.\n    let typeName = type.typeName;\n    if (reference instanceof Reference) {\n      if (!reference.hasOwningModuleGuess) {\n        throw new Error('A type reference to emit must be imported from an absolute module');\n      }\n\n      const emittedType = this.emitReference(reference);\n      if (!ts.isTypeReferenceNode(emittedType)) {\n        throw new Error(`Expected TypeReferenceNode for emitted reference, got ${\n            ts.SyntaxKind[emittedType.kind]}`);\n      }\n\n      typeName = emittedType.typeName;\n    }\n\n    return ts.updateTypeReferenceNode(type, typeName, typeArguments);\n  }\n}\n\n/**\n * Visitor interface that allows for unified recognition of the different types of `ts.TypeNode`s,\n * so that `visitTypeNode` is a centralized piece of recognition logic to be used in both\n * `canEmitType` and `TypeEmitter`.\n */\ninterface TypeEmitterVisitor<R> {\n  visitTypeReferenceNode(type: ts.TypeReferenceNode): R;\n  visitArrayTypeNode(type: ts.ArrayTypeNode): R;\n  visitKeywordType(type: ts.KeywordTypeNode): R;\n  visitLiteralType(type: ts.LiteralTypeNode): R;\n  visitOtherType(type: ts.TypeNode): R;\n}\n\nfunction visitTypeNode<R>(type: ts.TypeNode, visitor: TypeEmitterVisitor<R>): R {\n  if (ts.isTypeReferenceNode(type)) {\n    return visitor.visitTypeReferenceNode(type);\n  } else if (ts.isArrayTypeNode(type)) {\n    return visitor.visitArrayTypeNode(type);\n  } else if (ts.isLiteralTypeNode(type)) {\n    return visitor.visitLiteralType(type);\n  }\n\n  switch (type.kind) {\n    case ts.SyntaxKind.AnyKeyword:\n    case ts.SyntaxKind.UnknownKeyword:\n    case ts.SyntaxKind.NumberKeyword:\n    case ts.SyntaxKind.ObjectKeyword:\n    case ts.SyntaxKind.BooleanKeyword:\n    case ts.SyntaxKind.StringKeyword:\n    case ts.SyntaxKind.UndefinedKeyword:\n    case ts.SyntaxKind.NullKeyword:\n      return visitor.visitKeywordType(type as ts.KeywordTypeNode);\n    default:\n      return visitor.visitOtherType(type);\n  }\n}\n"]}

package/src/ngtsc/typecheck/src/type_parameter_emitter.mjs

@@ -1,80 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import * as ts from 'typescript';
-import { Reference } from '../../imports';
-import { canEmitType, TypeEmitter } from './type_emitter';
-/**
- * See `TypeEmitter` for more information on the emitting process.
- */
-export class TypeParameterEmitter {
-    constructor(typeParameters, reflector) {
-        this.typeParameters = typeParameters;
-        this.reflector = reflector;
-    }
-    /**
-     * Determines whether the type parameters can be emitted. If this returns true, then a call to
-     * `emit` is known to succeed. Vice versa, if false is returned then `emit` should not be
-     * called, as it would fail.
-     */
-    canEmit() {
-        if (this.typeParameters === undefined) {
-            return true;
-        }
-        return this.typeParameters.every(typeParam => {
-            if (typeParam.constraint === undefined) {
-                return true;
-            }
-            return canEmitType(typeParam.constraint, type => this.resolveTypeReference(type));
-        });
-    }
-    /**
-     * Emits the type parameters using the provided emitter function for `Reference`s.
-     */
-    emit(emitReference) {
-        if (this.typeParameters === undefined) {
-            return undefined;
-        }
-        const emitter = new TypeEmitter(type => this.resolveTypeReference(type), emitReference);
-        return this.typeParameters.map(typeParam => {
-            const constraint = typeParam.constraint !== undefined ? emitter.emitType(typeParam.constraint) : undefined;
-            return ts.updateTypeParameterDeclaration(
-            /* node */ typeParam, 
-            /* name */ typeParam.name, 
-            /* constraint */ constraint, 
-            /* defaultType */ typeParam.default);
-        });
-    }
-    resolveTypeReference(type) {
-        const target = ts.isIdentifier(type.typeName) ? type.typeName : type.typeName.right;
-        const declaration = this.reflector.getDeclarationOfIdentifier(target);
-        // If no declaration could be resolved or does not have a `ts.Declaration`, the type cannot be
-        // resolved.
-        if (declaration === null || declaration.node === null) {
-            return null;
-        }
-        // If the declaration corresponds with a local type parameter, the type reference can be used
-        // as is.
-        if (this.isLocalTypeParameter(declaration.node)) {
-            return type;
-        }
-        let owningModule = null;
-        if (declaration.viaModule !== null) {
-            owningModule = {
-                specifier: declaration.viaModule,
-                resolutionContext: type.getSourceFile().fileName,
-            };
-        }
-        return new Reference(declaration.node, owningModule);
-    }
-    isLocalTypeParameter(decl) {
-        // Checking for local type parameters only occurs during resolution of type parameters, so it is
-        // guaranteed that type parameters are present.
-        return this.typeParameters.some(param => param === decl);
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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

package/src/ngtsc/util/src/path.mjs

@@ -1,18 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { dirname, relative, resolve, toRelativeImport } from '../../file_system';
-import { stripExtension } from '../../file_system/src/util';
-export function relativePathBetween(from, to) {
-    const relativePath = stripExtension(relative(dirname(resolve(from)), resolve(to)));
-    return relativePath !== '' ? toRelativeImport(relativePath) : null;
-}
-export function normalizeSeparators(path) {
-    // TODO: normalize path only for OS that need it.
-    return path.replace(/\\/g, '/');
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9zcmMvbmd0c2MvdXRpbC9zcmMvcGF0aC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxPQUFPLEVBQUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUMsTUFBTSxtQkFBbUIsQ0FBQztBQUMvRSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sNEJBQTRCLENBQUM7QUFFMUQsTUFBTSxVQUFVLG1CQUFtQixDQUFDLElBQVksRUFBRSxFQUFVO0lBQzFELE1BQU0sWUFBWSxHQUFHLGNBQWMsQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxFQUFFLE9BQU8sQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDbkYsT0FBTyxZQUFZLEtBQUssRUFBRSxDQUFDLENBQUMsQ0FBQyxnQkFBZ0IsQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0FBQ3JFLENBQUM7QUFFRCxNQUFNLFVBQVUsbUJBQW1CLENBQUMsSUFBWTtJQUM5QyxpREFBaUQ7SUFDakQsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssRUFBRSxHQUFHLENBQUMsQ0FBQztBQUNsQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5pbXBvcnQge2Rpcm5hbWUsIHJlbGF0aXZlLCByZXNvbHZlLCB0b1JlbGF0aXZlSW1wb3J0fSBmcm9tICcuLi8uLi9maWxlX3N5c3RlbSc7XG5pbXBvcnQge3N0cmlwRXh0ZW5zaW9ufSBmcm9tICcuLi8uLi9maWxlX3N5c3RlbS9zcmMvdXRpbCc7XG5cbmV4cG9ydCBmdW5jdGlvbiByZWxhdGl2ZVBhdGhCZXR3ZWVuKGZyb206IHN0cmluZywgdG86IHN0cmluZyk6IHN0cmluZ3xudWxsIHtcbiAgY29uc3QgcmVsYXRpdmVQYXRoID0gc3RyaXBFeHRlbnNpb24ocmVsYXRpdmUoZGlybmFtZShyZXNvbHZlKGZyb20pKSwgcmVzb2x2ZSh0bykpKTtcbiAgcmV0dXJuIHJlbGF0aXZlUGF0aCAhPT0gJycgPyB0b1JlbGF0aXZlSW1wb3J0KHJlbGF0aXZlUGF0aCkgOiBudWxsO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gbm9ybWFsaXplU2VwYXJhdG9ycyhwYXRoOiBzdHJpbmcpOiBzdHJpbmcge1xuICAvLyBUT0RPOiBub3JtYWxpemUgcGF0aCBvbmx5IGZvciBPUyB0aGF0IG5lZWQgaXQuXG4gIHJldHVybiBwYXRoLnJlcGxhY2UoL1xcXFwvZywgJy8nKTtcbn1cbiJdfQ==