Conexio amb la api

node_modules/@angular/compiler-cli/linker/babel/index.d.ts

@@ -0,0 +1,11 @@
+/// <amd-module name="@angular/compiler-cli/linker/babel" />
+/**
+ * @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 { defaultLinkerPlugin } from './src/babel_plugin';
+export { createEs2015LinkerPlugin } from './src/es2015_linker_plugin';
+export default defaultLinkerPlugin;

node_modules/@angular/compiler-cli/linker/babel/index.js

@@ -0,0 +1,25 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/babel", ["require", "exports", "@angular/compiler-cli/linker/babel/src/babel_plugin", "@angular/compiler-cli/linker/babel/src/es2015_linker_plugin"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createEs2015LinkerPlugin = void 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
+     */
+    var babel_plugin_1 = require("@angular/compiler-cli/linker/babel/src/babel_plugin");
+    var es2015_linker_plugin_1 = require("@angular/compiler-cli/linker/babel/src/es2015_linker_plugin");
+    Object.defineProperty(exports, "createEs2015LinkerPlugin", { enumerable: true, get: function () { return es2015_linker_plugin_1.createEs2015LinkerPlugin; } });
+    exports.default = babel_plugin_1.defaultLinkerPlugin;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbGlua2VyL2JhYmVsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztJQUFBOzs7Ozs7T0FNRztJQUNILG9GQUF1RDtJQUV2RCxvR0FBb0U7SUFBNUQsZ0lBQUEsd0JBQXdCLE9BQUE7SUFDaEMsa0JBQWUsa0NBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7ZGVmYXVsdExpbmtlclBsdWdpbn0gZnJvbSAnLi9zcmMvYmFiZWxfcGx1Z2luJztcblxuZXhwb3J0IHtjcmVhdGVFczIwMTVMaW5rZXJQbHVnaW59IGZyb20gJy4vc3JjL2VzMjAxNV9saW5rZXJfcGx1Z2luJztcbmV4cG9ydCBkZWZhdWx0IGRlZmF1bHRMaW5rZXJQbHVnaW47XG4iXX0=

node_modules/@angular/compiler-cli/linker/babel/src/ast/babel_ast_factory.d.ts

@@ -0,0 +1,45 @@
+/// <amd-module name="@angular/compiler-cli/linker/babel/src/ast/babel_ast_factory" />
+/**
+ * @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 t from '@babel/types';
+import { AstFactory, BinaryOperator, LeadingComment, ObjectLiteralProperty, SourceMapRange, TemplateLiteral, VariableDeclarationType } from '../../../../src/ngtsc/translator';
+/**
+ * A Babel flavored implementation of the AstFactory.
+ */
+export declare class BabelAstFactory implements AstFactory<t.Statement, t.Expression> {
+    /** The absolute path to the source file being compiled. */
+    private sourceUrl;
+    constructor(
+    /** The absolute path to the source file being compiled. */
+    sourceUrl: string);
+    attachComments(statement: t.Statement, leadingComments: LeadingComment[]): void;
+    createArrayLiteral: typeof t.arrayExpression;
+    createAssignment(target: t.Expression, value: t.Expression): t.Expression;
+    createBinaryExpression(leftOperand: t.Expression, operator: BinaryOperator, rightOperand: t.Expression): t.Expression;
+    createBlock: typeof t.blockStatement;
+    createCallExpression(callee: t.Expression, args: t.Expression[], pure: boolean): t.Expression;
+    createConditional: typeof t.conditionalExpression;
+    createElementAccess(expression: t.Expression, element: t.Expression): t.Expression;
+    createExpressionStatement: typeof t.expressionStatement;
+    createFunctionDeclaration(functionName: string, parameters: string[], body: t.Statement): t.Statement;
+    createFunctionExpression(functionName: string | null, parameters: string[], body: t.Statement): t.Expression;
+    createIdentifier: typeof t.identifier;
+    createIfStatement: typeof t.ifStatement;
+    createLiteral(value: string | number | boolean | null | undefined): t.Expression;
+    createNewExpression: typeof t.newExpression;
+    createObjectLiteral(properties: ObjectLiteralProperty<t.Expression>[]): t.Expression;
+    createParenthesizedExpression: typeof t.parenthesizedExpression;
+    createPropertyAccess(expression: t.Expression, propertyName: string): t.Expression;
+    createReturnStatement: typeof t.returnStatement;
+    createTaggedTemplate(tag: t.Expression, template: TemplateLiteral<t.Expression>): t.Expression;
+    createThrowStatement: typeof t.throwStatement;
+    createTypeOfExpression(expression: t.Expression): t.Expression;
+    createUnaryExpression: typeof t.unaryExpression;
+    createVariableDeclaration(variableName: string, initializer: t.Expression | null, type: VariableDeclarationType): t.Statement;
+    setSourceMapRange<T extends t.Statement | t.Expression | t.TemplateElement>(node: T, sourceMapRange: SourceMapRange | null): T;
+}

node_modules/@angular/compiler-cli/linker/babel/src/ast/babel_ast_host.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/linker/babel/src/ast/babel_ast_host" />
+import * as t from '@babel/types';
+import { AstHost, Range } from '../../../../linker';
+/**
+ * This implementation of `AstHost` is able to get information from Babel AST nodes.
+ */
+export declare class BabelAstHost implements AstHost<t.Expression> {
+    getSymbolName(node: t.Expression): string | null;
+    isStringLiteral: typeof t.isStringLiteral;
+    parseStringLiteral(str: t.Expression): string;
+    isNumericLiteral: typeof t.isNumericLiteral;
+    parseNumericLiteral(num: t.Expression): number;
+    isBooleanLiteral(bool: t.Expression): boolean;
+    parseBooleanLiteral(bool: t.Expression): boolean;
+    isArrayLiteral: typeof t.isArrayExpression;
+    parseArrayLiteral(array: t.Expression): t.Expression[];
+    isObjectLiteral: typeof t.isObjectExpression;
+    parseObjectLiteral(obj: t.Expression): Map<string, t.Expression>;
+    isFunctionExpression(node: t.Expression): node is Extract<t.Function, t.Expression>;
+    parseReturnValue(fn: t.Expression): t.Expression;
+    isCallExpression: typeof t.isCallExpression;
+    parseCallee(call: t.Expression): t.Expression;
+    parseArguments(call: t.Expression): t.Expression[];
+    getRange(node: t.Expression): Range;
+}

node_modules/@angular/compiler-cli/linker/babel/src/babel_declaration_scope.d.ts

@@ -0,0 +1,38 @@
+/// <amd-module name="@angular/compiler-cli/linker/babel/src/babel_declaration_scope" />
+/**
+ * @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 { NodePath, Scope } from '@babel/traverse';
+import * as t from '@babel/types';
+import { DeclarationScope } from '../../../linker';
+export declare type ConstantScopePath = NodePath<t.Function | t.Program>;
+/**
+ * This class represents the lexical scope of a partial declaration in Babel source code.
+ *
+ * Its only responsibility is to compute a reference object for the scope of shared constant
+ * statements that will be generated during partial linking.
+ */
+export declare class BabelDeclarationScope implements DeclarationScope<ConstantScopePath, t.Expression> {
+    private declarationScope;
+    /**
+     * Construct a new `BabelDeclarationScope`.
+     *
+     * @param declarationScope the Babel scope containing the declaration call expression.
+     */
+    constructor(declarationScope: Scope);
+    /**
+     * Compute the Babel `NodePath` that can be used to reference the lexical scope where any
+     * shared constant statements would be inserted.
+     *
+     * There will only be a shared constant scope if the expression is in an ECMAScript module, or a
+     * UMD module. Otherwise `null` is returned to indicate that constant statements must be emitted
+     * locally to the generated linked definition, to avoid polluting the global scope.
+     *
+     * @param expression the expression that points to the Angular core framework import.
+     */
+    getConstantScopeRef(expression: t.Expression): ConstantScopePath | null;
+}

node_modules/@angular/compiler-cli/linker/babel/src/babel_plugin.d.ts

@@ -0,0 +1,26 @@
+/// <amd-module name="@angular/compiler-cli/linker/babel/src/babel_plugin" />
+/**
+ * @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 { ConfigAPI, PluginObj } from '@babel/core';
+import { LinkerOptions } from '../../src/file_linker/linker_options';
+/**
+ * This is the Babel plugin definition that is provided as a default export from the package, such
+ * that the plugin can be used using the module specifier of the package. This is the recommended
+ * way of integrating the Angular Linker into a build pipeline other than the Angular CLI.
+ *
+ * When the module specifier `@angular/compiler-cli/linker/babel` is used as a plugin in a Babel
+ * configuration, Babel invokes this function (by means of the default export) to create the plugin
+ * instance according to the provided options.
+ *
+ * The linker plugin that is created uses the native NodeJS filesystem APIs to interact with the
+ * filesystem. Any logging output is printed to the console.
+ *
+ * @param api Provides access to the Babel environment that is configuring this plugin.
+ * @param options The plugin options that have been configured.
+ */
+export declare function defaultLinkerPlugin(api: ConfigAPI, options: Partial<LinkerOptions>): PluginObj;

node_modules/@angular/compiler-cli/linker/babel/src/babel_plugin.js

@@ -0,0 +1,38 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/babel/src/babel_plugin", ["require", "exports", "tslib", "@angular/compiler-cli/src/ngtsc/file_system", "@angular/compiler-cli/src/ngtsc/logging", "@angular/compiler-cli/linker/babel/src/es2015_linker_plugin"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.defaultLinkerPlugin = void 0;
+    var tslib_1 = require("tslib");
+    var file_system_1 = require("@angular/compiler-cli/src/ngtsc/file_system");
+    var logging_1 = require("@angular/compiler-cli/src/ngtsc/logging");
+    var es2015_linker_plugin_1 = require("@angular/compiler-cli/linker/babel/src/es2015_linker_plugin");
+    /**
+     * This is the Babel plugin definition that is provided as a default export from the package, such
+     * that the plugin can be used using the module specifier of the package. This is the recommended
+     * way of integrating the Angular Linker into a build pipeline other than the Angular CLI.
+     *
+     * When the module specifier `@angular/compiler-cli/linker/babel` is used as a plugin in a Babel
+     * configuration, Babel invokes this function (by means of the default export) to create the plugin
+     * instance according to the provided options.
+     *
+     * The linker plugin that is created uses the native NodeJS filesystem APIs to interact with the
+     * filesystem. Any logging output is printed to the console.
+     *
+     * @param api Provides access to the Babel environment that is configuring this plugin.
+     * @param options The plugin options that have been configured.
+     */
+    function defaultLinkerPlugin(api, options) {
+        api.assertVersion(7);
+        return es2015_linker_plugin_1.createEs2015LinkerPlugin(tslib_1.__assign(tslib_1.__assign({}, options), { fileSystem: new file_system_1.NodeJSFileSystem(), logger: new logging_1.ConsoleLogger(logging_1.LogLevel.info) }));
+    }
+    exports.defaultLinkerPlugin = defaultLinkerPlugin;
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/babel/src/es2015_linker_plugin.d.ts

@@ -0,0 +1,17 @@
+/// <amd-module name="@angular/compiler-cli/linker/babel/src/es2015_linker_plugin" />
+/**
+ * @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 { PluginObj } from '@babel/core';
+import { LinkerPluginOptions } from './linker_plugin_options';
+/**
+ * Create a Babel plugin that visits the program, identifying and linking partial declarations.
+ *
+ * The plugin delegates most of its work to a generic `FileLinker` for each file (`t.Program` in
+ * Babel) that is visited.
+ */
+export declare function createEs2015LinkerPlugin({ fileSystem, logger, ...options }: LinkerPluginOptions): PluginObj;

node_modules/@angular/compiler-cli/linker/babel/src/linker_plugin_options.d.ts

@@ -0,0 +1,21 @@
+/// <amd-module name="@angular/compiler-cli/linker/babel/src/linker_plugin_options" />
+/**
+ * @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 { LinkerOptions } from '../..';
+import { ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
+import { Logger } from '../../../src/ngtsc/logging';
+export interface LinkerPluginOptions extends Partial<LinkerOptions> {
+    /**
+     * File-system, used to load up the input source-map and content.
+     */
+    fileSystem: ReadonlyFileSystem;
+    /**
+     * Logger used by the linker.
+     */
+    logger: Logger;
+}

node_modules/@angular/compiler-cli/linker/babel/src/linker_plugin_options.js

@@ -0,0 +1,13 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/babel/src/linker_plugin_options", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlua2VyX3BsdWdpbl9vcHRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL2xpbmtlci9iYWJlbC9zcmMvbGlua2VyX3BsdWdpbl9vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7TGlua2VyT3B0aW9uc30gZnJvbSAnLi4vLi4nO1xuaW1wb3J0IHtSZWFkb25seUZpbGVTeXN0ZW19IGZyb20gJy4uLy4uLy4uL3NyYy9uZ3RzYy9maWxlX3N5c3RlbSc7XG5pbXBvcnQge0xvZ2dlcn0gZnJvbSAnLi4vLi4vLi4vc3JjL25ndHNjL2xvZ2dpbmcnO1xuXG5leHBvcnQgaW50ZXJmYWNlIExpbmtlclBsdWdpbk9wdGlvbnMgZXh0ZW5kcyBQYXJ0aWFsPExpbmtlck9wdGlvbnM+IHtcbiAgLyoqXG4gICAqIEZpbGUtc3lzdGVtLCB1c2VkIHRvIGxvYWQgdXAgdGhlIGlucHV0IHNvdXJjZS1tYXAgYW5kIGNvbnRlbnQuXG4gICAqL1xuICBmaWxlU3lzdGVtOiBSZWFkb25seUZpbGVTeXN0ZW07XG5cbiAgLyoqXG4gICAqIExvZ2dlciB1c2VkIGJ5IHRoZSBsaW5rZXIuXG4gICAqL1xuICBsb2dnZXI6IExvZ2dlcjtcbn1cbiJdfQ==

node_modules/@angular/compiler-cli/linker/index.d.ts

@@ -0,0 +1,16 @@
+/// <amd-module name="@angular/compiler-cli/linker" />
+/**
+ * @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
+ */
+export { AstHost, Range } from './src/ast/ast_host';
+export { assert } from './src/ast/utils';
+export { FatalLinkerError, isFatalLinkerError } from './src/fatal_linker_error';
+export { DeclarationScope } from './src/file_linker/declaration_scope';
+export { FileLinker } from './src/file_linker/file_linker';
+export { LinkerEnvironment } from './src/file_linker/linker_environment';
+export { DEFAULT_LINKER_OPTIONS, LinkerOptions } from './src/file_linker/linker_options';
+export { needsLinking } from './src/file_linker/needs_linking';

node_modules/@angular/compiler-cli/linker/index.js

@@ -0,0 +1,27 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker", ["require", "exports", "@angular/compiler-cli/linker/src/ast/utils", "@angular/compiler-cli/linker/src/fatal_linker_error", "@angular/compiler-cli/linker/src/file_linker/file_linker", "@angular/compiler-cli/linker/src/file_linker/linker_environment", "@angular/compiler-cli/linker/src/file_linker/linker_options", "@angular/compiler-cli/linker/src/file_linker/needs_linking"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.needsLinking = exports.DEFAULT_LINKER_OPTIONS = exports.LinkerEnvironment = exports.FileLinker = exports.isFatalLinkerError = exports.FatalLinkerError = exports.assert = void 0;
+    var utils_1 = require("@angular/compiler-cli/linker/src/ast/utils");
+    Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return utils_1.assert; } });
+    var fatal_linker_error_1 = require("@angular/compiler-cli/linker/src/fatal_linker_error");
+    Object.defineProperty(exports, "FatalLinkerError", { enumerable: true, get: function () { return fatal_linker_error_1.FatalLinkerError; } });
+    Object.defineProperty(exports, "isFatalLinkerError", { enumerable: true, get: function () { return fatal_linker_error_1.isFatalLinkerError; } });
+    var file_linker_1 = require("@angular/compiler-cli/linker/src/file_linker/file_linker");
+    Object.defineProperty(exports, "FileLinker", { enumerable: true, get: function () { return file_linker_1.FileLinker; } });
+    var linker_environment_1 = require("@angular/compiler-cli/linker/src/file_linker/linker_environment");
+    Object.defineProperty(exports, "LinkerEnvironment", { enumerable: true, get: function () { return linker_environment_1.LinkerEnvironment; } });
+    var linker_options_1 = require("@angular/compiler-cli/linker/src/file_linker/linker_options");
+    Object.defineProperty(exports, "DEFAULT_LINKER_OPTIONS", { enumerable: true, get: function () { return linker_options_1.DEFAULT_LINKER_OPTIONS; } });
+    var needs_linking_1 = require("@angular/compiler-cli/linker/src/file_linker/needs_linking");
+    Object.defineProperty(exports, "needsLinking", { enumerable: true, get: function () { return needs_linking_1.needsLinking; } });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbGlua2VyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztJQVFBLG9FQUF1QztJQUEvQiwrRkFBQSxNQUFNLE9BQUE7SUFDZCwwRkFBOEU7SUFBdEUsc0hBQUEsZ0JBQWdCLE9BQUE7SUFBRSx3SEFBQSxrQkFBa0IsT0FBQTtJQUU1Qyx3RkFBeUQ7SUFBakQseUdBQUEsVUFBVSxPQUFBO0lBQ2xCLHNHQUF1RTtJQUEvRCx1SEFBQSxpQkFBaUIsT0FBQTtJQUN6Qiw4RkFBdUY7SUFBL0Usd0hBQUEsc0JBQXNCLE9BQUE7SUFDOUIsNEZBQTZEO0lBQXJELDZHQUFBLFlBQVksT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuZXhwb3J0IHtBc3RIb3N0LCBSYW5nZX0gZnJvbSAnLi9zcmMvYXN0L2FzdF9ob3N0JztcbmV4cG9ydCB7YXNzZXJ0fSBmcm9tICcuL3NyYy9hc3QvdXRpbHMnO1xuZXhwb3J0IHtGYXRhbExpbmtlckVycm9yLCBpc0ZhdGFsTGlua2VyRXJyb3J9IGZyb20gJy4vc3JjL2ZhdGFsX2xpbmtlcl9lcnJvcic7XG5leHBvcnQge0RlY2xhcmF0aW9uU2NvcGV9IGZyb20gJy4vc3JjL2ZpbGVfbGlua2VyL2RlY2xhcmF0aW9uX3Njb3BlJztcbmV4cG9ydCB7RmlsZUxpbmtlcn0gZnJvbSAnLi9zcmMvZmlsZV9saW5rZXIvZmlsZV9saW5rZXInO1xuZXhwb3J0IHtMaW5rZXJFbnZpcm9ubWVudH0gZnJvbSAnLi9zcmMvZmlsZV9saW5rZXIvbGlua2VyX2Vudmlyb25tZW50JztcbmV4cG9ydCB7REVGQVVMVF9MSU5LRVJfT1BUSU9OUywgTGlua2VyT3B0aW9uc30gZnJvbSAnLi9zcmMvZmlsZV9saW5rZXIvbGlua2VyX29wdGlvbnMnO1xuZXhwb3J0IHtuZWVkc0xpbmtpbmd9IGZyb20gJy4vc3JjL2ZpbGVfbGlua2VyL25lZWRzX2xpbmtpbmcnO1xuIl19

node_modules/@angular/compiler-cli/linker/src/ast/ast_host.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/linker/src/ast/ast_host" />
+/**
+ * An abstraction for getting information from an AST while being agnostic to the underlying AST
+ * implementation.
+ */
+export interface AstHost<TExpression> {
+    /**
+     * Get the name of the symbol represented by the given expression node, or `null` if it is not a
+     * symbol.
+     */
+    getSymbolName(node: TExpression): string | null;
+    /**
+     * Return `true` if the given expression is a string literal, or false otherwise.
+     */
+    isStringLiteral(node: TExpression): boolean;
+    /**
+     * Parse the string value from the given expression, or throw if it is not a string literal.
+     */
+    parseStringLiteral(str: TExpression): string;
+    /**
+     * Return `true` if the given expression is a numeric literal, or false otherwise.
+     */
+    isNumericLiteral(node: TExpression): boolean;
+    /**
+     * Parse the numeric value from the given expression, or throw if it is not a numeric literal.
+     */
+    parseNumericLiteral(num: TExpression): number;
+    /**
+     * Return `true` if the given expression can be considered a boolean literal, or false otherwise.
+     *
+     * Note that this should also cover the special case of some minified code where `true` and
+     * `false` are replaced by `!0` and `!1` respectively.
+     */
+    isBooleanLiteral(node: TExpression): boolean;
+    /**
+     * Parse the boolean value from the given expression, or throw if it is not a boolean literal.
+     *
+     * Note that this should also cover the special case of some minified code where `true` and
+     * `false` are replaced by `!0` and `!1` respectively.
+     */
+    parseBooleanLiteral(bool: TExpression): boolean;
+    /**
+     * Return `true` if the given expression is an array literal, or false otherwise.
+     */
+    isArrayLiteral(node: TExpression): boolean;
+    /**
+     * Parse an array of expressions from the given expression, or throw if it is not an array
+     * literal.
+     */
+    parseArrayLiteral(array: TExpression): TExpression[];
+    /**
+     * Return `true` if the given expression is an object literal, or false otherwise.
+     */
+    isObjectLiteral(node: TExpression): boolean;
+    /**
+     * Parse the given expression into a map of object property names to property expressions, or
+     * throw if it is not an object literal.
+     */
+    parseObjectLiteral(obj: TExpression): Map<string, TExpression>;
+    /**
+     * Return `true` if the given expression is a function, or false otherwise.
+     */
+    isFunctionExpression(node: TExpression): boolean;
+    /**
+     * Compute the "value" of a function expression by parsing its body for a single `return`
+     * statement, extracting the returned expression, or throw if it is not possible.
+     */
+    parseReturnValue(fn: TExpression): TExpression;
+    /**
+     * Return true if the given expression is a call expression, or false otherwise.
+     */
+    isCallExpression(node: TExpression): boolean;
+    /**
+     * Returns the expression that is called in the provided call expression, or throw if it is not
+     * a call expression.
+     */
+    parseCallee(call: TExpression): TExpression;
+    /**
+     * Returns the argument expressions for the provided call expression, or throw if it is not
+     * a call expression.
+     */
+    parseArguments(call: TExpression): TExpression[];
+    /**
+     * Compute the location range of the expression in the source file, to be used for source-mapping.
+     */
+    getRange(node: TExpression): Range;
+}
+/**
+ * The location of the start and end of an expression in the original source file.
+ */
+export interface Range {
+    /** 0-based character position of the range start in the source file text. */
+    startPos: number;
+    /** 0-based line index of the range start in the source file text. */
+    startLine: number;
+    /** 0-based column position of the range start in the source file text. */
+    startCol: number;
+    /** 0-based character position of the range end in the source file text. */
+    endPos: number;
+}

node_modules/@angular/compiler-cli/linker/src/ast/ast_value.d.ts

@@ -0,0 +1,202 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/ast/ast_value" />
+/**
+ * @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 o from '@angular/compiler';
+import { AstHost, Range } from './ast_host';
+/**
+ * Represents only those types in `T` that are object types.
+ */
+declare type ObjectType<T> = Extract<T, object>;
+/**
+ * Represents the value type of an object literal.
+ */
+declare type ObjectValueType<T> = T extends Record<string, infer R> ? R : never;
+/**
+ * Represents the value type of an array literal.
+ */
+declare type ArrayValueType<T> = T extends Array<infer R> ? R : never;
+/**
+ * Ensures that `This` has its generic type `Actual` conform to the expected generic type in
+ * `Expected`, to disallow calling a method if the generic type does not conform.
+ */
+declare type ConformsTo<This, Actual, Expected> = Actual extends Expected ? This : never;
+/**
+ * Ensures that `This` is an `AstValue` whose generic type conforms to `Expected`, to disallow
+ * calling a method if the value's type does not conform.
+ */
+declare type HasValueType<This, Expected> = This extends AstValue<infer Actual, any> ? ConformsTo<This, Actual, Expected> : never;
+/**
+ * Represents only the string keys of type `T`.
+ */
+declare type PropertyKey<T> = keyof T & string;
+/**
+ * This helper class wraps an object expression along with an `AstHost` object, exposing helper
+ * methods that make it easier to extract the properties of the object.
+ *
+ * The generic `T` is used as reference type of the expected structure that is represented by this
+ * object. It does not achieve full type-safety for the provided operations in correspondence with
+ * `T`; its main goal is to provide references to a documented type and ensure that the properties
+ * that are read from the object are present.
+ *
+ * Unfortunately, the generic types are unable to prevent reading an optional property from the
+ * object without first having called `has` to ensure that the property exists. This is one example
+ * of where full type-safety is not achieved.
+ */
+export declare class AstObject<T extends object, TExpression> {
+    readonly expression: TExpression;
+    private obj;
+    private host;
+    /**
+     * Create a new `AstObject` from the given `expression` and `host`.
+     */
+    static parse<T extends object, TExpression>(expression: TExpression, host: AstHost<TExpression>): AstObject<T, TExpression>;
+    private constructor();
+    /**
+     * Returns true if the object has a property called `propertyName`.
+     */
+    has(propertyName: PropertyKey<T>): boolean;
+    /**
+     * Returns the number value of the property called `propertyName`.
+     *
+     * Throws an error if there is no such property or the property is not a number.
+     */
+    getNumber<K extends PropertyKey<T>>(this: ConformsTo<this, T[K], number>, propertyName: K): number;
+    /**
+     * Returns the string value of the property called `propertyName`.
+     *
+     * Throws an error if there is no such property or the property is not a string.
+     */
+    getString<K extends PropertyKey<T>>(this: ConformsTo<this, T[K], string>, propertyName: K): string;
+    /**
+     * Returns the boolean value of the property called `propertyName`.
+     *
+     * Throws an error if there is no such property or the property is not a boolean.
+     */
+    getBoolean<K extends PropertyKey<T>>(this: ConformsTo<this, T[K], boolean>, propertyName: K): boolean;
+    /**
+     * Returns the nested `AstObject` parsed from the property called `propertyName`.
+     *
+     * Throws an error if there is no such property or the property is not an object.
+     */
+    getObject<K extends PropertyKey<T>>(this: ConformsTo<this, T[K], object>, propertyName: K): AstObject<ObjectType<T[K]>, TExpression>;
+    /**
+     * Returns an array of `AstValue` objects parsed from the property called `propertyName`.
+     *
+     * Throws an error if there is no such property or the property is not an array.
+     */
+    getArray<K extends PropertyKey<T>>(this: ConformsTo<this, T[K], unknown[]>, propertyName: K): AstValue<ArrayValueType<T[K]>, TExpression>[];
+    /**
+     * Returns a `WrappedNodeExpr` object that wraps the expression at the property called
+     * `propertyName`.
+     *
+     * Throws an error if there is no such property.
+     */
+    getOpaque(propertyName: PropertyKey<T>): o.WrappedNodeExpr<TExpression>;
+    /**
+     * Returns the raw `TExpression` value of the property called `propertyName`.
+     *
+     * Throws an error if there is no such property.
+     */
+    getNode(propertyName: PropertyKey<T>): TExpression;
+    /**
+     * Returns an `AstValue` that wraps the value of the property called `propertyName`.
+     *
+     * Throws an error if there is no such property.
+     */
+    getValue<K extends PropertyKey<T>>(propertyName: K): AstValue<T[K], TExpression>;
+    /**
+     * Converts the AstObject to a raw JavaScript object, mapping each property value (as an
+     * `AstValue`) to the generic type (`T`) via the `mapper` function.
+     */
+    toLiteral<V>(mapper: (value: AstValue<ObjectValueType<T>, TExpression>) => V): Record<string, V>;
+    /**
+     * Converts the AstObject to a JavaScript Map, mapping each property value (as an
+     * `AstValue`) to the generic type (`T`) via the `mapper` function.
+     */
+    toMap<V>(mapper: (value: AstValue<ObjectValueType<T>, TExpression>) => V): Map<string, V>;
+    private getRequiredProperty;
+}
+/**
+ * This helper class wraps an `expression`, exposing methods that use the `host` to give
+ * access to the underlying value of the wrapped expression.
+ *
+ * The generic `T` is used as reference type of the expected type that is represented by this value.
+ * It does not achieve full type-safety for the provided operations in correspondence with `T`; its
+ * main goal is to provide references to a documented type.
+ */
+export declare class AstValue<T, TExpression> {
+    readonly expression: TExpression;
+    private host;
+    constructor(expression: TExpression, host: AstHost<TExpression>);
+    /**
+     * Get the name of the symbol represented by the given expression node, or `null` if it is not a
+     * symbol.
+     */
+    getSymbolName(): string | null;
+    /**
+     * Is this value a number?
+     */
+    isNumber(): boolean;
+    /**
+     * Parse the number from this value, or error if it is not a number.
+     */
+    getNumber(this: HasValueType<this, number>): number;
+    /**
+     * Is this value a string?
+     */
+    isString(): boolean;
+    /**
+     * Parse the string from this value, or error if it is not a string.
+     */
+    getString(this: HasValueType<this, string>): string;
+    /**
+     * Is this value a boolean?
+     */
+    isBoolean(): boolean;
+    /**
+     * Parse the boolean from this value, or error if it is not a boolean.
+     */
+    getBoolean(this: HasValueType<this, boolean>): boolean;
+    /**
+     * Is this value an object literal?
+     */
+    isObject(): boolean;
+    /**
+     * Parse this value into an `AstObject`, or error if it is not an object literal.
+     */
+    getObject(this: HasValueType<this, object>): AstObject<ObjectType<T>, TExpression>;
+    /**
+     * Is this value an array literal?
+     */
+    isArray(): boolean;
+    /**
+     * Parse this value into an array of `AstValue` objects, or error if it is not an array literal.
+     */
+    getArray(this: HasValueType<this, unknown[]>): AstValue<ArrayValueType<T>, TExpression>[];
+    /**
+     * Is this value a function expression?
+     */
+    isFunction(): boolean;
+    /**
+     * Extract the return value as an `AstValue` from this value as a function expression, or error if
+     * it is not a function expression.
+     */
+    getFunctionReturnValue<R>(this: HasValueType<this, Function>): AstValue<R, TExpression>;
+    isCallExpression(): boolean;
+    getCallee(): AstValue<unknown, TExpression>;
+    getArguments(): AstValue<unknown, TExpression>[];
+    /**
+     * Return the `TExpression` of this value wrapped in a `WrappedNodeExpr`.
+     */
+    getOpaque(): o.WrappedNodeExpr<TExpression>;
+    /**
+     * Get the range of the location of this value in the original source.
+     */
+    getRange(): Range;
+}
+export {};

node_modules/@angular/compiler-cli/linker/src/ast/typescript/typescript_ast_host.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/linker/src/ast/typescript/typescript_ast_host" />
+import * as ts from 'typescript';
+import { AstHost, Range } from '../ast_host';
+/**
+ * This implementation of `AstHost` is able to get information from TypeScript AST nodes.
+ *
+ * This host is not actually used at runtime in the current code.
+ *
+ * It is implemented here to ensure that the `AstHost` abstraction is not unfairly skewed towards
+ * the Babel implementation. It could also provide a basis for a 3rd TypeScript compiler plugin to
+ * do linking in the future.
+ */
+export declare class TypeScriptAstHost implements AstHost<ts.Expression> {
+    getSymbolName(node: ts.Expression): string | null;
+    isStringLiteral: typeof ts.isStringLiteral;
+    parseStringLiteral(str: ts.Expression): string;
+    isNumericLiteral: typeof ts.isNumericLiteral;
+    parseNumericLiteral(num: ts.Expression): number;
+    isBooleanLiteral(node: ts.Expression): boolean;
+    parseBooleanLiteral(bool: ts.Expression): boolean;
+    isArrayLiteral: typeof ts.isArrayLiteralExpression;
+    parseArrayLiteral(array: ts.Expression): ts.Expression[];
+    isObjectLiteral: typeof ts.isObjectLiteralExpression;
+    parseObjectLiteral(obj: ts.Expression): Map<string, ts.Expression>;
+    isFunctionExpression(node: ts.Expression): node is ts.FunctionExpression | ts.ArrowFunction;
+    parseReturnValue(fn: ts.Expression): ts.Expression;
+    isCallExpression: typeof ts.isCallExpression;
+    parseCallee(call: ts.Expression): ts.Expression;
+    parseArguments(call: ts.Expression): ts.Expression[];
+    getRange(node: ts.Expression): Range;
+}

node_modules/@angular/compiler-cli/linker/src/ast/utils.d.ts

@@ -0,0 +1,5 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/ast/utils" />
+/**
+ * Assert that the given `node` is of the type guarded by the `predicate` function.
+ */
+export declare function assert<T, K extends T>(node: T, predicate: (node: T) => node is K, expected: string): asserts node is K;

node_modules/@angular/compiler-cli/linker/src/ast/utils.js

@@ -0,0 +1,31 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/ast/utils", ["require", "exports", "@angular/compiler-cli/linker/src/fatal_linker_error"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.assert = void 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
+     */
+    var fatal_linker_error_1 = require("@angular/compiler-cli/linker/src/fatal_linker_error");
+    /**
+     * Assert that the given `node` is of the type guarded by the `predicate` function.
+     */
+    function assert(node, predicate, expected) {
+        if (!predicate(node)) {
+            throw new fatal_linker_error_1.FatalLinkerError(node, "Unsupported syntax, expected " + expected + ".");
+        }
+    }
+    exports.assert = assert;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbGlua2VyL3NyYy9hc3QvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0lBQUE7Ozs7OztPQU1HO0lBQ0gsMEZBQXVEO0lBRXZEOztPQUVHO0lBQ0gsU0FBZ0IsTUFBTSxDQUNsQixJQUFPLEVBQUUsU0FBaUMsRUFBRSxRQUFnQjtRQUM5RCxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFO1lBQ3BCLE1BQU0sSUFBSSxxQ0FBZ0IsQ0FBQyxJQUFJLEVBQUUsa0NBQWdDLFFBQVEsTUFBRyxDQUFDLENBQUM7U0FDL0U7SUFDSCxDQUFDO0lBTEQsd0JBS0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7RmF0YWxMaW5rZXJFcnJvcn0gZnJvbSAnLi4vZmF0YWxfbGlua2VyX2Vycm9yJztcblxuLyoqXG4gKiBBc3NlcnQgdGhhdCB0aGUgZ2l2ZW4gYG5vZGVgIGlzIG9mIHRoZSB0eXBlIGd1YXJkZWQgYnkgdGhlIGBwcmVkaWNhdGVgIGZ1bmN0aW9uLlxuICovXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0PFQsIEsgZXh0ZW5kcyBUPihcbiAgICBub2RlOiBULCBwcmVkaWNhdGU6IChub2RlOiBUKSA9PiBub2RlIGlzIEssIGV4cGVjdGVkOiBzdHJpbmcpOiBhc3NlcnRzIG5vZGUgaXMgSyB7XG4gIGlmICghcHJlZGljYXRlKG5vZGUpKSB7XG4gICAgdGhyb3cgbmV3IEZhdGFsTGlua2VyRXJyb3Iobm9kZSwgYFVuc3VwcG9ydGVkIHN5bnRheCwgZXhwZWN0ZWQgJHtleHBlY3RlZH0uYCk7XG4gIH1cbn1cbiJdfQ==

node_modules/@angular/compiler-cli/linker/src/fatal_linker_error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/linker/src/fatal_linker_error" />
+/**
+ * An unrecoverable error during linking.
+ */
+export declare class FatalLinkerError extends Error {
+    node: unknown;
+    readonly type = "FatalLinkerError";
+    /**
+     * Create a new FatalLinkerError.
+     *
+     * @param node The AST node where the error occurred.
+     * @param message A description of the error.
+     */
+    constructor(node: unknown, message: string);
+}
+/**
+ * Whether the given object `e` is a FatalLinkerError.
+ */
+export declare function isFatalLinkerError(e: any): e is FatalLinkerError;

node_modules/@angular/compiler-cli/linker/src/fatal_linker_error.js

@@ -0,0 +1,49 @@
+/**
+ * @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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/fatal_linker_error", ["require", "exports", "tslib"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isFatalLinkerError = exports.FatalLinkerError = void 0;
+    var tslib_1 = require("tslib");
+    /**
+     * An unrecoverable error during linking.
+     */
+    var FatalLinkerError = /** @class */ (function (_super) {
+        tslib_1.__extends(FatalLinkerError, _super);
+        /**
+         * Create a new FatalLinkerError.
+         *
+         * @param node The AST node where the error occurred.
+         * @param message A description of the error.
+         */
+        function FatalLinkerError(node, message) {
+            var _this = _super.call(this, message) || this;
+            _this.node = node;
+            _this.type = 'FatalLinkerError';
+            return _this;
+        }
+        return FatalLinkerError;
+    }(Error));
+    exports.FatalLinkerError = FatalLinkerError;
+    /**
+     * Whether the given object `e` is a FatalLinkerError.
+     */
+    function isFatalLinkerError(e) {
+        return e && e.type === 'FatalLinkerError';
+    }
+    exports.isFatalLinkerError = isFatalLinkerError;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmF0YWxfbGlua2VyX2Vycm9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29tcGlsZXItY2xpL2xpbmtlci9zcmMvZmF0YWxfbGlua2VyX2Vycm9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRzs7Ozs7Ozs7Ozs7Ozs7SUFFSDs7T0FFRztJQUNIO1FBQXNDLDRDQUFLO1FBR3pDOzs7OztXQUtHO1FBQ0gsMEJBQW1CLElBQWEsRUFBRSxPQUFlO1lBQWpELFlBQ0Usa0JBQU0sT0FBTyxDQUFDLFNBQ2Y7WUFGa0IsVUFBSSxHQUFKLElBQUksQ0FBUztZQVJ2QixVQUFJLEdBQUcsa0JBQWtCLENBQUM7O1FBVW5DLENBQUM7UUFDSCx1QkFBQztJQUFELENBQUMsQUFaRCxDQUFzQyxLQUFLLEdBWTFDO0lBWlksNENBQWdCO0lBYzdCOztPQUVHO0lBQ0gsU0FBZ0Isa0JBQWtCLENBQUMsQ0FBTTtRQUN2QyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxLQUFLLGtCQUFrQixDQUFDO0lBQzVDLENBQUM7SUFGRCxnREFFQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG4vKipcbiAqIEFuIHVucmVjb3ZlcmFibGUgZXJyb3IgZHVyaW5nIGxpbmtpbmcuXG4gKi9cbmV4cG9ydCBjbGFzcyBGYXRhbExpbmtlckVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICByZWFkb25seSB0eXBlID0gJ0ZhdGFsTGlua2VyRXJyb3InO1xuXG4gIC8qKlxuICAgKiBDcmVhdGUgYSBuZXcgRmF0YWxMaW5rZXJFcnJvci5cbiAgICpcbiAgICogQHBhcmFtIG5vZGUgVGhlIEFTVCBub2RlIHdoZXJlIHRoZSBlcnJvciBvY2N1cnJlZC5cbiAgICogQHBhcmFtIG1lc3NhZ2UgQSBkZXNjcmlwdGlvbiBvZiB0aGUgZXJyb3IuXG4gICAqL1xuICBjb25zdHJ1Y3RvcihwdWJsaWMgbm9kZTogdW5rbm93biwgbWVzc2FnZTogc3RyaW5nKSB7XG4gICAgc3VwZXIobWVzc2FnZSk7XG4gIH1cbn1cblxuLyoqXG4gKiBXaGV0aGVyIHRoZSBnaXZlbiBvYmplY3QgYGVgIGlzIGEgRmF0YWxMaW5rZXJFcnJvci5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGlzRmF0YWxMaW5rZXJFcnJvcihlOiBhbnkpOiBlIGlzIEZhdGFsTGlua2VyRXJyb3Ige1xuICByZXR1cm4gZSAmJiBlLnR5cGUgPT09ICdGYXRhbExpbmtlckVycm9yJztcbn1cbiJdfQ==

node_modules/@angular/compiler-cli/linker/src/file_linker/declaration_scope.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/declaration_scope" />
+/**
+ * This interface represents the lexical scope of a partial declaration in the source code.
+ *
+ * For example, if you had the following code:
+ *
+ * ```
+ * function foo() {
+ *   function bar () {
+ *     ɵɵngDeclareDirective({...});
+ *   }
+ * }
+ * ```
+ *
+ * The `DeclarationScope` of the `ɵɵngDeclareDirective()` call is the body of the `bar()` function.
+ *
+ * The `FileLinker` uses this object to identify the lexical scope of any constant statements that
+ * might be generated by the linking process (i.e. where the `ConstantPool` lives for a set of
+ * partial linkers).
+ */
+export interface DeclarationScope<TSharedConstantScope, TExpression> {
+    /**
+     * Get a `TSharedConstantScope` object that can be used to reference the lexical scope where any
+     * shared constant statements would be inserted.
+     *
+     * This object is generic because different AST implementations will need different
+     * `TConstantScope` types to be able to insert shared constant statements. For example in Babel
+     * this would be a `NodePath` object; in TS it would just be a `Node` object.
+     *
+     * If it is not possible to find such a shared scope, then constant statements will be wrapped up
+     * with their generated linked definition expression, in the form of an IIFE.
+     *
+     * @param expression the expression that points to the Angular core framework import.
+     * @returns a reference to a reference object for where the shared constant statements will be
+     *     inserted, or `null` if it is not possible to have a shared scope.
+     */
+    getConstantScopeRef(expression: TExpression): TSharedConstantScope | null;
+}

node_modules/@angular/compiler-cli/linker/src/file_linker/declaration_scope.js

@@ -0,0 +1,20 @@
+/**
+ * @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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/declaration_scope", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/src/file_linker/emit_scopes/emit_scope.d.ts

@@ -0,0 +1,36 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/emit_scopes/emit_scope" />
+/**
+ * @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 { ConstantPool } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { Translator } from '../translator';
+/**
+ * This class represents (from the point of view of the `FileLinker`) the scope in which
+ * statements and expressions related to a linked partial declaration will be emitted.
+ *
+ * It holds a copy of a `ConstantPool` that is used to capture any constant statements that need to
+ * be emitted in this context.
+ *
+ * This implementation will emit the definition and the constant statements separately.
+ */
+export declare class EmitScope<TStatement, TExpression> {
+    protected readonly ngImport: TExpression;
+    protected readonly translator: Translator<TStatement, TExpression>;
+    readonly constantPool: ConstantPool;
+    constructor(ngImport: TExpression, translator: Translator<TStatement, TExpression>);
+    /**
+     * Translate the given Output AST definition expression into a generic `TExpression`.
+     *
+     * Use a `LinkerImportGenerator` to handle any imports in the definition.
+     */
+    translateDefinition(definition: o.Expression): TExpression;
+    /**
+     * Return any constant statements that are shared between all uses of this `EmitScope`.
+     */
+    getConstantStatements(): TStatement[];
+}

node_modules/@angular/compiler-cli/linker/src/file_linker/emit_scopes/emit_scope.js

@@ -0,0 +1,57 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/emit_scopes/emit_scope", ["require", "exports", "@angular/compiler", "@angular/compiler-cli/linker/src/linker_import_generator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EmitScope = void 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
+     */
+    var compiler_1 = require("@angular/compiler");
+    var linker_import_generator_1 = require("@angular/compiler-cli/linker/src/linker_import_generator");
+    /**
+     * This class represents (from the point of view of the `FileLinker`) the scope in which
+     * statements and expressions related to a linked partial declaration will be emitted.
+     *
+     * It holds a copy of a `ConstantPool` that is used to capture any constant statements that need to
+     * be emitted in this context.
+     *
+     * This implementation will emit the definition and the constant statements separately.
+     */
+    var EmitScope = /** @class */ (function () {
+        function EmitScope(ngImport, translator) {
+            this.ngImport = ngImport;
+            this.translator = translator;
+            this.constantPool = new compiler_1.ConstantPool();
+        }
+        /**
+         * Translate the given Output AST definition expression into a generic `TExpression`.
+         *
+         * Use a `LinkerImportGenerator` to handle any imports in the definition.
+         */
+        EmitScope.prototype.translateDefinition = function (definition) {
+            return this.translator.translateExpression(definition, new linker_import_generator_1.LinkerImportGenerator(this.ngImport));
+        };
+        /**
+         * Return any constant statements that are shared between all uses of this `EmitScope`.
+         */
+        EmitScope.prototype.getConstantStatements = function () {
+            var _this = this;
+            var importGenerator = new linker_import_generator_1.LinkerImportGenerator(this.ngImport);
+            return this.constantPool.statements.map(function (statement) { return _this.translator.translateStatement(statement, importGenerator); });
+        };
+        return EmitScope;
+    }());
+    exports.EmitScope = EmitScope;
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/src/file_linker/emit_scopes/iife_emit_scope.d.ts

@@ -0,0 +1,33 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/emit_scopes/iife_emit_scope" />
+/**
+ * @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 o from '@angular/compiler/src/output/output_ast';
+import { AstFactory } from '../../../../src/ngtsc/translator';
+import { Translator } from '../translator';
+import { EmitScope } from './emit_scope';
+/**
+ * This class is a specialization of the `EmitScope` class that is designed for the situation where
+ * there is no clear shared scope for constant statements. In this case they are bundled with the
+ * translated definition inside an IIFE.
+ */
+export declare class IifeEmitScope<TStatement, TExpression> extends EmitScope<TStatement, TExpression> {
+    private readonly factory;
+    constructor(ngImport: TExpression, translator: Translator<TStatement, TExpression>, factory: AstFactory<TStatement, TExpression>);
+    /**
+     * Translate the given Output AST definition expression into a generic `TExpression`.
+     *
+     * Wraps the output from `EmitScope.translateDefinition()` and `EmitScope.getConstantStatements()`
+     * in an IIFE.
+     */
+    translateDefinition(definition: o.Expression): TExpression;
+    /**
+     * It is not valid to call this method, since there will be no shared constant statements - they
+     * are already emitted in the IIFE alongside the translated definition.
+     */
+    getConstantStatements(): TStatement[];
+}

node_modules/@angular/compiler-cli/linker/src/file_linker/emit_scopes/iife_emit_scope.js

@@ -0,0 +1,51 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/emit_scopes/iife_emit_scope", ["require", "exports", "tslib", "@angular/compiler-cli/linker/src/file_linker/emit_scopes/emit_scope"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.IifeEmitScope = void 0;
+    var tslib_1 = require("tslib");
+    var emit_scope_1 = require("@angular/compiler-cli/linker/src/file_linker/emit_scopes/emit_scope");
+    /**
+     * This class is a specialization of the `EmitScope` class that is designed for the situation where
+     * there is no clear shared scope for constant statements. In this case they are bundled with the
+     * translated definition inside an IIFE.
+     */
+    var IifeEmitScope = /** @class */ (function (_super) {
+        tslib_1.__extends(IifeEmitScope, _super);
+        function IifeEmitScope(ngImport, translator, factory) {
+            var _this = _super.call(this, ngImport, translator) || this;
+            _this.factory = factory;
+            return _this;
+        }
+        /**
+         * Translate the given Output AST definition expression into a generic `TExpression`.
+         *
+         * Wraps the output from `EmitScope.translateDefinition()` and `EmitScope.getConstantStatements()`
+         * in an IIFE.
+         */
+        IifeEmitScope.prototype.translateDefinition = function (definition) {
+            var constantStatements = _super.prototype.getConstantStatements.call(this);
+            var returnStatement = this.factory.createReturnStatement(_super.prototype.translateDefinition.call(this, definition));
+            var body = this.factory.createBlock(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(constantStatements)), [returnStatement]));
+            var fn = this.factory.createFunctionExpression(/* name */ null, /* args */ [], body);
+            return this.factory.createCallExpression(fn, /* args */ [], /* pure */ false);
+        };
+        /**
+         * It is not valid to call this method, since there will be no shared constant statements - they
+         * are already emitted in the IIFE alongside the translated definition.
+         */
+        IifeEmitScope.prototype.getConstantStatements = function () {
+            throw new Error('BUG - IifeEmitScope should not expose any constant statements');
+        };
+        return IifeEmitScope;
+    }(emit_scope_1.EmitScope));
+    exports.IifeEmitScope = IifeEmitScope;
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/src/file_linker/file_linker.d.ts

@@ -0,0 +1,40 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/file_linker" />
+import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
+import { DeclarationScope } from './declaration_scope';
+import { LinkerEnvironment } from './linker_environment';
+export declare const NO_STATEMENTS: Readonly<any[]>;
+/**
+ * This class is responsible for linking all the partial declarations found in a single file.
+ */
+export declare class FileLinker<TConstantScope, TStatement, TExpression> {
+    private linkerEnvironment;
+    private linkerSelector;
+    private emitScopes;
+    constructor(linkerEnvironment: LinkerEnvironment<TStatement, TExpression>, sourceUrl: AbsoluteFsPath, code: string);
+    /**
+     * Return true if the given callee name matches a partial declaration that can be linked.
+     */
+    isPartialDeclaration(calleeName: string): boolean;
+    /**
+     * Link the metadata extracted from the args of a call to a partial declaration function.
+     *
+     * The `declarationScope` is used to determine the scope and strategy of emission of the linked
+     * definition and any shared constant statements.
+     *
+     * @param declarationFn the name of the function used to declare the partial declaration - e.g.
+     *     `ɵɵngDeclareDirective`.
+     * @param args the arguments passed to the declaration function, should be a single object that
+     *     corresponds to the `R3DeclareDirectiveMetadata` or `R3DeclareComponentMetadata` interfaces.
+     * @param declarationScope the scope that contains this call to the declaration function.
+     */
+    linkPartialDeclaration(declarationFn: string, args: TExpression[], declarationScope: DeclarationScope<TConstantScope, TExpression>): TExpression;
+    /**
+     * Return all the shared constant statements and their associated constant scope references, so
+     * that they can be inserted into the source code.
+     */
+    getConstantStatements(): {
+        constantScope: TConstantScope;
+        statements: TStatement[];
+    }[];
+    private getEmitScope;
+}

node_modules/@angular/compiler-cli/linker/src/file_linker/get_source_file.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/get_source_file" />
+import { AbsoluteFsPath } from '../../../src/ngtsc/file_system';
+import { SourceFile, SourceFileLoader } from '../../../src/ngtsc/sourcemaps';
+/**
+ * A function that will return a `SourceFile` object (or null) for the current file being linked.
+ */
+export declare type GetSourceFileFn = () => SourceFile | null;
+/**
+ * Create a `GetSourceFileFn` that will return the `SourceFile` being linked or `null`, if not
+ * available.
+ */
+export declare function createGetSourceFile(sourceUrl: AbsoluteFsPath, code: string, loader: SourceFileLoader | null): GetSourceFileFn;

node_modules/@angular/compiler-cli/linker/src/file_linker/get_source_file.js

@@ -0,0 +1,42 @@
+/**
+ * @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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/get_source_file", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createGetSourceFile = void 0;
+    /**
+     * Create a `GetSourceFileFn` that will return the `SourceFile` being linked or `null`, if not
+     * available.
+     */
+    function createGetSourceFile(sourceUrl, code, loader) {
+        if (loader === null) {
+            // No source-mapping so just return a function that always returns `null`.
+            return function () { return null; };
+        }
+        else {
+            // Source-mapping is available so return a function that will load (and cache) the `SourceFile`.
+            var sourceFile_1 = undefined;
+            return function () {
+                if (sourceFile_1 === undefined) {
+                    sourceFile_1 = loader.loadSourceFile(sourceUrl, code);
+                }
+                return sourceFile_1;
+            };
+        }
+    }
+    exports.createGetSourceFile = createGetSourceFile;
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/src/file_linker/linker_environment.d.ts

@@ -0,0 +1,26 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/linker_environment" />
+/**
+ * @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 { ReadonlyFileSystem } from '../../../src/ngtsc/file_system';
+import { Logger } from '../../../src/ngtsc/logging';
+import { SourceFileLoader } from '../../../src/ngtsc/sourcemaps';
+import { AstFactory } from '../../../src/ngtsc/translator';
+import { AstHost } from '../ast/ast_host';
+import { LinkerOptions } from './linker_options';
+import { Translator } from './translator';
+export declare class LinkerEnvironment<TStatement, TExpression> {
+    readonly fileSystem: ReadonlyFileSystem;
+    readonly logger: Logger;
+    readonly host: AstHost<TExpression>;
+    readonly factory: AstFactory<TStatement, TExpression>;
+    readonly options: LinkerOptions;
+    readonly translator: Translator<TStatement, TExpression>;
+    readonly sourceFileLoader: SourceFileLoader | null;
+    private constructor();
+    static create<TStatement, TExpression>(fileSystem: ReadonlyFileSystem, logger: Logger, host: AstHost<TExpression>, factory: AstFactory<TStatement, TExpression>, options: Partial<LinkerOptions>): LinkerEnvironment<TStatement, TExpression>;
+}

node_modules/@angular/compiler-cli/linker/src/file_linker/linker_environment.js

@@ -0,0 +1,38 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/linker_environment", ["require", "exports", "@angular/compiler-cli/src/ngtsc/sourcemaps", "@angular/compiler-cli/linker/src/file_linker/linker_options", "@angular/compiler-cli/linker/src/file_linker/translator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LinkerEnvironment = void 0;
+    var sourcemaps_1 = require("@angular/compiler-cli/src/ngtsc/sourcemaps");
+    var linker_options_1 = require("@angular/compiler-cli/linker/src/file_linker/linker_options");
+    var translator_1 = require("@angular/compiler-cli/linker/src/file_linker/translator");
+    var LinkerEnvironment = /** @class */ (function () {
+        function LinkerEnvironment(fileSystem, logger, host, factory, options) {
+            this.fileSystem = fileSystem;
+            this.logger = logger;
+            this.host = host;
+            this.factory = factory;
+            this.options = options;
+            this.translator = new translator_1.Translator(this.factory);
+            this.sourceFileLoader = this.options.sourceMapping ? new sourcemaps_1.SourceFileLoader(this.fileSystem, this.logger, {}) : null;
+        }
+        LinkerEnvironment.create = function (fileSystem, logger, host, factory, options) {
+            var _a, _b, _c;
+            return new LinkerEnvironment(fileSystem, logger, host, factory, {
+                sourceMapping: (_a = options.sourceMapping) !== null && _a !== void 0 ? _a : linker_options_1.DEFAULT_LINKER_OPTIONS.sourceMapping,
+                linkerJitMode: (_b = options.linkerJitMode) !== null && _b !== void 0 ? _b : linker_options_1.DEFAULT_LINKER_OPTIONS.linkerJitMode,
+                unknownDeclarationVersionHandling: (_c = options.unknownDeclarationVersionHandling) !== null && _c !== void 0 ? _c : linker_options_1.DEFAULT_LINKER_OPTIONS.unknownDeclarationVersionHandling,
+            });
+        };
+        return LinkerEnvironment;
+    }());
+    exports.LinkerEnvironment = LinkerEnvironment;
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/src/file_linker/linker_options.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/linker_options" />
+/**
+ * Options to configure the linking behavior.
+ */
+export interface LinkerOptions {
+    /**
+     * Whether to use source-mapping to compute the original source for external templates.
+     * The default is `true`.
+     */
+    sourceMapping: boolean;
+    /**
+     * This option tells the linker to generate information used by a downstream JIT compiler.
+     *
+     * Specifically, in JIT mode, NgModule definitions must describe the `declarations`, `imports`,
+     * `exports`, etc, which are otherwise not needed.
+     */
+    linkerJitMode: boolean;
+    /**
+     * How to handle a situation where a partial declaration matches none of the supported
+     * partial-linker versions.
+     *
+     * - `error` - the version mismatch is a fatal error.
+     * - `warn` - a warning is sent to the logger but the most recent partial-linker
+     *   will attempt to process the declaration anyway.
+     * - `ignore` - the most recent partial-linker will, silently, attempt to process
+     *   the declaration.
+     *
+     * The default is `error`.
+     */
+    unknownDeclarationVersionHandling: 'ignore' | 'warn' | 'error';
+}
+/**
+ * The default linker options to use if properties are not provided.
+ */
+export declare const DEFAULT_LINKER_OPTIONS: LinkerOptions;

node_modules/@angular/compiler-cli/linker/src/file_linker/linker_options.js

@@ -0,0 +1,29 @@
+/**
+ * @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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/linker_options", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DEFAULT_LINKER_OPTIONS = void 0;
+    /**
+     * The default linker options to use if properties are not provided.
+     */
+    exports.DEFAULT_LINKER_OPTIONS = {
+        sourceMapping: true,
+        linkerJitMode: false,
+        unknownDeclarationVersionHandling: 'error',
+    };
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/src/file_linker/needs_linking.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @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
+ */
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/needs_linking" />
+/**
+ * Determines if the provided source file may need to be processed by the linker, i.e. whether it
+ * potentially contains any declarations. If true is returned, then the source file should be
+ * processed by the linker as it may contain declarations that need to be fully compiled. If false
+ * is returned, parsing and processing of the source file can safely be skipped to improve
+ * performance.
+ *
+ * This function may return true even for source files that don't actually contain any declarations
+ * that need to be compiled.
+ *
+ * @param path the absolute path of the source file for which to determine whether linking may be
+ * needed.
+ * @param source the source file content as a string.
+ * @returns whether the source file may contain declarations that need to be linked.
+ */
+export declare function needsLinking(path: string, source: string): boolean;

node_modules/@angular/compiler-cli/linker/src/file_linker/needs_linking.js

@@ -0,0 +1,41 @@
+/**
+ * @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
+ */
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/needs_linking", ["require", "exports", "@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_linker_selector"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.needsLinking = void 0;
+    var partial_linker_selector_1 = require("@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_linker_selector");
+    /**
+     * Determines if the provided source file may need to be processed by the linker, i.e. whether it
+     * potentially contains any declarations. If true is returned, then the source file should be
+     * processed by the linker as it may contain declarations that need to be fully compiled. If false
+     * is returned, parsing and processing of the source file can safely be skipped to improve
+     * performance.
+     *
+     * This function may return true even for source files that don't actually contain any declarations
+     * that need to be compiled.
+     *
+     * @param path the absolute path of the source file for which to determine whether linking may be
+     * needed.
+     * @param source the source file content as a string.
+     * @returns whether the source file may contain declarations that need to be linked.
+     */
+    function needsLinking(path, source) {
+        return partial_linker_selector_1.declarationFunctions.some(function (fn) { return source.includes(fn); });
+    }
+    exports.needsLinking = needsLinking;
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_class_metadata_linker_1.d.ts

@@ -0,0 +1,22 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_class_metadata_linker_1" />
+/**
+ * @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 { ConstantPool, R3ClassMetadata, R3DeclareClassMetadata, R3PartialDeclaration } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { AstObject } from '../../ast/ast_value';
+import { PartialLinker } from './partial_linker';
+/**
+ * A `PartialLinker` that is designed to process `ɵɵngDeclareClassMetadata()` call expressions.
+ */
+export declare class PartialClassMetadataLinkerVersion1<TExpression> implements PartialLinker<TExpression> {
+    linkPartialDeclaration(constantPool: ConstantPool, metaObj: AstObject<R3PartialDeclaration, TExpression>): o.Expression;
+}
+/**
+ * Derives the `R3ClassMetadata` structure from the AST object.
+ */
+export declare function toR3ClassMetadata<TExpression>(metaObj: AstObject<R3DeclareClassMetadata, TExpression>): R3ClassMetadata;

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_class_metadata_linker_1.js

@@ -0,0 +1,47 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_class_metadata_linker_1", ["require", "exports", "@angular/compiler"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.toR3ClassMetadata = exports.PartialClassMetadataLinkerVersion1 = void 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
+     */
+    var compiler_1 = require("@angular/compiler");
+    /**
+     * A `PartialLinker` that is designed to process `ɵɵngDeclareClassMetadata()` call expressions.
+     */
+    var PartialClassMetadataLinkerVersion1 = /** @class */ (function () {
+        function PartialClassMetadataLinkerVersion1() {
+        }
+        PartialClassMetadataLinkerVersion1.prototype.linkPartialDeclaration = function (constantPool, metaObj) {
+            var meta = toR3ClassMetadata(metaObj);
+            return compiler_1.compileClassMetadata(meta);
+        };
+        return PartialClassMetadataLinkerVersion1;
+    }());
+    exports.PartialClassMetadataLinkerVersion1 = PartialClassMetadataLinkerVersion1;
+    /**
+     * Derives the `R3ClassMetadata` structure from the AST object.
+     */
+    function toR3ClassMetadata(metaObj) {
+        return {
+            type: metaObj.getOpaque('type'),
+            decorators: metaObj.getOpaque('decorators'),
+            ctorParameters: metaObj.has('ctorParameters') ? metaObj.getOpaque('ctorParameters') : null,
+            propDecorators: metaObj.has('propDecorators') ? metaObj.getOpaque('propDecorators') : null,
+        };
+    }
+    exports.toR3ClassMetadata = toR3ClassMetadata;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFydGlhbF9jbGFzc19tZXRhZGF0YV9saW5rZXJfMS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvbXBpbGVyLWNsaS9saW5rZXIvc3JjL2ZpbGVfbGlua2VyL3BhcnRpYWxfbGlua2Vycy9wYXJ0aWFsX2NsYXNzX21ldGFkYXRhX2xpbmtlcl8xLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztJQUFBOzs7Ozs7T0FNRztJQUNILDhDQUFvSTtJQU9wSTs7T0FFRztJQUNIO1FBQUE7UUFPQSxDQUFDO1FBTkMsbUVBQXNCLEdBQXRCLFVBQ0ksWUFBMEIsRUFDMUIsT0FBcUQ7WUFDdkQsSUFBTSxJQUFJLEdBQUcsaUJBQWlCLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDeEMsT0FBTywrQkFBb0IsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNwQyxDQUFDO1FBQ0gseUNBQUM7SUFBRCxDQUFDLEFBUEQsSUFPQztJQVBZLGdGQUFrQztJQVMvQzs7T0FFRztJQUNILFNBQWdCLGlCQUFpQixDQUM3QixPQUF1RDtRQUN6RCxPQUFPO1lBQ0wsSUFBSSxFQUFFLE9BQU8sQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDO1lBQy9CLFVBQVUsRUFBRSxPQUFPLENBQUMsU0FBUyxDQUFDLFlBQVksQ0FBQztZQUMzQyxjQUFjLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUMsQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLGdCQUFnQixDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUk7WUFDMUYsY0FBYyxFQUFFLE9BQU8sQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJO1NBQzNGLENBQUM7SUFDSixDQUFDO0lBUkQsOENBUUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7Y29tcGlsZUNsYXNzTWV0YWRhdGEsIENvbnN0YW50UG9vbCwgUjNDbGFzc01ldGFkYXRhLCBSM0RlY2xhcmVDbGFzc01ldGFkYXRhLCBSM1BhcnRpYWxEZWNsYXJhdGlvbn0gZnJvbSAnQGFuZ3VsYXIvY29tcGlsZXInO1xuaW1wb3J0ICogYXMgbyBmcm9tICdAYW5ndWxhci9jb21waWxlci9zcmMvb3V0cHV0L291dHB1dF9hc3QnO1xuXG5pbXBvcnQge0FzdE9iamVjdH0gZnJvbSAnLi4vLi4vYXN0L2FzdF92YWx1ZSc7XG5cbmltcG9ydCB7UGFydGlhbExpbmtlcn0gZnJvbSAnLi9wYXJ0aWFsX2xpbmtlcic7XG5cbi8qKlxuICogQSBgUGFydGlhbExpbmtlcmAgdGhhdCBpcyBkZXNpZ25lZCB0byBwcm9jZXNzIGDJtcm1bmdEZWNsYXJlQ2xhc3NNZXRhZGF0YSgpYCBjYWxsIGV4cHJlc3Npb25zLlxuICovXG5leHBvcnQgY2xhc3MgUGFydGlhbENsYXNzTWV0YWRhdGFMaW5rZXJWZXJzaW9uMTxURXhwcmVzc2lvbj4gaW1wbGVtZW50cyBQYXJ0aWFsTGlua2VyPFRFeHByZXNzaW9uPiB7XG4gIGxpbmtQYXJ0aWFsRGVjbGFyYXRpb24oXG4gICAgICBjb25zdGFudFBvb2w6IENvbnN0YW50UG9vbCxcbiAgICAgIG1ldGFPYmo6IEFzdE9iamVjdDxSM1BhcnRpYWxEZWNsYXJhdGlvbiwgVEV4cHJlc3Npb24+KTogby5FeHByZXNzaW9uIHtcbiAgICBjb25zdCBtZXRhID0gdG9SM0NsYXNzTWV0YWRhdGEobWV0YU9iaik7XG4gICAgcmV0dXJuIGNvbXBpbGVDbGFzc01ldGFkYXRhKG1ldGEpO1xuICB9XG59XG5cbi8qKlxuICogRGVyaXZlcyB0aGUgYFIzQ2xhc3NNZXRhZGF0YWAgc3RydWN0dXJlIGZyb20gdGhlIEFTVCBvYmplY3QuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB0b1IzQ2xhc3NNZXRhZGF0YTxURXhwcmVzc2lvbj4oXG4gICAgbWV0YU9iajogQXN0T2JqZWN0PFIzRGVjbGFyZUNsYXNzTWV0YWRhdGEsIFRFeHByZXNzaW9uPik6IFIzQ2xhc3NNZXRhZGF0YSB7XG4gIHJldHVybiB7XG4gICAgdHlwZTogbWV0YU9iai5nZXRPcGFxdWUoJ3R5cGUnKSxcbiAgICBkZWNvcmF0b3JzOiBtZXRhT2JqLmdldE9wYXF1ZSgnZGVjb3JhdG9ycycpLFxuICAgIGN0b3JQYXJhbWV0ZXJzOiBtZXRhT2JqLmhhcygnY3RvclBhcmFtZXRlcnMnKSA/IG1ldGFPYmouZ2V0T3BhcXVlKCdjdG9yUGFyYW1ldGVycycpIDogbnVsbCxcbiAgICBwcm9wRGVjb3JhdG9yczogbWV0YU9iai5oYXMoJ3Byb3BEZWNvcmF0b3JzJykgPyBtZXRhT2JqLmdldE9wYXF1ZSgncHJvcERlY29yYXRvcnMnKSA6IG51bGwsXG4gIH07XG59XG4iXX0=

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_component_linker_1.d.ts

@@ -0,0 +1,34 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_component_linker_1" />
+/**
+ * @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 { ConstantPool, R3PartialDeclaration } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system';
+import { AstObject } from '../../ast/ast_value';
+import { GetSourceFileFn } from '../get_source_file';
+import { PartialLinker } from './partial_linker';
+/**
+ * A `PartialLinker` that is designed to process `ɵɵngDeclareComponent()` call expressions.
+ */
+export declare class PartialComponentLinkerVersion1<TStatement, TExpression> implements PartialLinker<TExpression> {
+    private readonly getSourceFile;
+    private sourceUrl;
+    private code;
+    constructor(getSourceFile: GetSourceFileFn, sourceUrl: AbsoluteFsPath, code: string);
+    linkPartialDeclaration(constantPool: ConstantPool, metaObj: AstObject<R3PartialDeclaration, TExpression>): o.Expression;
+    /**
+     * This function derives the `R3ComponentMetadata` from the provided AST object.
+     */
+    private toR3ComponentMeta;
+    /**
+     * Update the range to remove the start and end chars, which should be quotes around the template.
+     */
+    private getTemplateInfo;
+    private tryExternalTemplate;
+    private templateFromPartialCode;
+}

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_directive_linker_1.d.ts

@@ -0,0 +1,28 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_directive_linker_1" />
+/**
+ * @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 { ConstantPool, ParseSourceSpan, R3DeclareDirectiveMetadata, R3DirectiveMetadata, R3PartialDeclaration } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system';
+import { Range } from '../../ast/ast_host';
+import { AstObject } from '../../ast/ast_value';
+import { PartialLinker } from './partial_linker';
+/**
+ * A `PartialLinker` that is designed to process `ɵɵngDeclareDirective()` call expressions.
+ */
+export declare class PartialDirectiveLinkerVersion1<TExpression> implements PartialLinker<TExpression> {
+    private sourceUrl;
+    private code;
+    constructor(sourceUrl: AbsoluteFsPath, code: string);
+    linkPartialDeclaration(constantPool: ConstantPool, metaObj: AstObject<R3PartialDeclaration, TExpression>): o.Expression;
+}
+/**
+ * Derives the `R3DirectiveMetadata` structure from the AST object.
+ */
+export declare function toR3DirectiveMeta<TExpression>(metaObj: AstObject<R3DeclareDirectiveMetadata, TExpression>, code: string, sourceUrl: AbsoluteFsPath): R3DirectiveMetadata;
+export declare function createSourceSpan(range: Range, code: string, sourceUrl: string): ParseSourceSpan;

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_factory_linker_1.d.ts

@@ -0,0 +1,22 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_factory_linker_1" />
+/**
+ * @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 { ConstantPool, R3DeclareFactoryMetadata, R3FactoryMetadata, R3PartialDeclaration } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { AstObject } from '../../ast/ast_value';
+import { PartialLinker } from './partial_linker';
+/**
+ * A `PartialLinker` that is designed to process `ɵɵngDeclareFactory()` call expressions.
+ */
+export declare class PartialFactoryLinkerVersion1<TExpression> implements PartialLinker<TExpression> {
+    linkPartialDeclaration(constantPool: ConstantPool, metaObj: AstObject<R3PartialDeclaration, TExpression>): o.Expression;
+}
+/**
+ * Derives the `R3FactoryMetadata` structure from the AST object.
+ */
+export declare function toR3FactoryMeta<TExpression>(metaObj: AstObject<R3DeclareFactoryMetadata, TExpression>): R3FactoryMetadata;

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_injectable_linker_1.d.ts

@@ -0,0 +1,22 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_injectable_linker_1" />
+/**
+ * @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 { ConstantPool, R3DeclareInjectableMetadata, R3InjectableMetadata, R3PartialDeclaration } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { AstObject } from '../../ast/ast_value';
+import { PartialLinker } from './partial_linker';
+/**
+ * A `PartialLinker` that is designed to process `ɵɵngDeclareInjectable()` call expressions.
+ */
+export declare class PartialInjectableLinkerVersion1<TExpression> implements PartialLinker<TExpression> {
+    linkPartialDeclaration(constantPool: ConstantPool, metaObj: AstObject<R3PartialDeclaration, TExpression>): o.Expression;
+}
+/**
+ * Derives the `R3InjectableMetadata` structure from the AST object.
+ */
+export declare function toR3InjectableMeta<TExpression>(metaObj: AstObject<R3DeclareInjectableMetadata, TExpression>): R3InjectableMetadata;

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_injector_linker_1.d.ts

@@ -0,0 +1,22 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_injector_linker_1" />
+/**
+ * @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 { ConstantPool, R3DeclareInjectorMetadata, R3InjectorMetadata, R3PartialDeclaration } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { AstObject } from '../../ast/ast_value';
+import { PartialLinker } from './partial_linker';
+/**
+ * A `PartialLinker` that is designed to process `ɵɵngDeclareInjector()` call expressions.
+ */
+export declare class PartialInjectorLinkerVersion1<TExpression> implements PartialLinker<TExpression> {
+    linkPartialDeclaration(constantPool: ConstantPool, metaObj: AstObject<R3PartialDeclaration, TExpression>): o.Expression;
+}
+/**
+ * Derives the `R3InjectorMetadata` structure from the AST object.
+ */
+export declare function toR3InjectorMeta<TExpression>(metaObj: AstObject<R3DeclareInjectorMetadata, TExpression>): R3InjectorMetadata;

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_injector_linker_1.js

@@ -0,0 +1,56 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_injector_linker_1", ["require", "exports", "@angular/compiler", "@angular/compiler-cli/linker/src/fatal_linker_error", "@angular/compiler-cli/linker/src/file_linker/partial_linkers/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.toR3InjectorMeta = exports.PartialInjectorLinkerVersion1 = void 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
+     */
+    var compiler_1 = require("@angular/compiler");
+    var fatal_linker_error_1 = require("@angular/compiler-cli/linker/src/fatal_linker_error");
+    var util_1 = require("@angular/compiler-cli/linker/src/file_linker/partial_linkers/util");
+    /**
+     * A `PartialLinker` that is designed to process `ɵɵngDeclareInjector()` call expressions.
+     */
+    var PartialInjectorLinkerVersion1 = /** @class */ (function () {
+        function PartialInjectorLinkerVersion1() {
+        }
+        PartialInjectorLinkerVersion1.prototype.linkPartialDeclaration = function (constantPool, metaObj) {
+            var meta = toR3InjectorMeta(metaObj);
+            var def = compiler_1.compileInjector(meta);
+            return def.expression;
+        };
+        return PartialInjectorLinkerVersion1;
+    }());
+    exports.PartialInjectorLinkerVersion1 = PartialInjectorLinkerVersion1;
+    /**
+     * Derives the `R3InjectorMetadata` structure from the AST object.
+     */
+    function toR3InjectorMeta(metaObj) {
+        var typeExpr = metaObj.getValue('type');
+        var typeName = typeExpr.getSymbolName();
+        if (typeName === null) {
+            throw new fatal_linker_error_1.FatalLinkerError(typeExpr.expression, 'Unsupported type, its name could not be determined');
+        }
+        return {
+            name: typeName,
+            type: util_1.wrapReference(typeExpr.getOpaque()),
+            internalType: metaObj.getOpaque('type'),
+            providers: metaObj.has('providers') ? metaObj.getOpaque('providers') : null,
+            imports: metaObj.has('imports') ? metaObj.getArray('imports').map(function (i) { return i.getOpaque(); }) : [],
+        };
+    }
+    exports.toR3InjectorMeta = toR3InjectorMeta;
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_linker.d.ts

@@ -0,0 +1,23 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_linker" />
+/**
+ * @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 { ConstantPool, R3PartialDeclaration } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { AstObject } from '../../ast/ast_value';
+/**
+ * An interface for classes that can link partial declarations into full definitions.
+ */
+export interface PartialLinker<TExpression> {
+    /**
+     * Link the partial declaration `metaObj` information to generate a full definition expression.
+     *
+     * @param metaObj An object that fits one of the `R3DeclareDirectiveMetadata` or
+     *     `R3DeclareComponentMetadata` interfaces.
+     */
+    linkPartialDeclaration(constantPool: ConstantPool, metaObj: AstObject<R3PartialDeclaration, TExpression>): o.Expression;
+}

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_linker.js

@@ -0,0 +1,13 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_linker", ["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFydGlhbF9saW5rZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb21waWxlci1jbGkvbGlua2VyL3NyYy9maWxlX2xpbmtlci9wYXJ0aWFsX2xpbmtlcnMvcGFydGlhbF9saW5rZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuaW1wb3J0IHtDb25zdGFudFBvb2wsIFIzUGFydGlhbERlY2xhcmF0aW9ufSBmcm9tICdAYW5ndWxhci9jb21waWxlcic7XG5pbXBvcnQgKiBhcyBvIGZyb20gJ0Bhbmd1bGFyL2NvbXBpbGVyL3NyYy9vdXRwdXQvb3V0cHV0X2FzdCc7XG5cbmltcG9ydCB7QXN0T2JqZWN0fSBmcm9tICcuLi8uLi9hc3QvYXN0X3ZhbHVlJztcblxuLyoqXG4gKiBBbiBpbnRlcmZhY2UgZm9yIGNsYXNzZXMgdGhhdCBjYW4gbGluayBwYXJ0aWFsIGRlY2xhcmF0aW9ucyBpbnRvIGZ1bGwgZGVmaW5pdGlvbnMuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUGFydGlhbExpbmtlcjxURXhwcmVzc2lvbj4ge1xuICAvKipcbiAgICogTGluayB0aGUgcGFydGlhbCBkZWNsYXJhdGlvbiBgbWV0YU9iamAgaW5mb3JtYXRpb24gdG8gZ2VuZXJhdGUgYSBmdWxsIGRlZmluaXRpb24gZXhwcmVzc2lvbi5cbiAgICpcbiAgICogQHBhcmFtIG1ldGFPYmogQW4gb2JqZWN0IHRoYXQgZml0cyBvbmUgb2YgdGhlIGBSM0RlY2xhcmVEaXJlY3RpdmVNZXRhZGF0YWAgb3JcbiAgICogICAgIGBSM0RlY2xhcmVDb21wb25lbnRNZXRhZGF0YWAgaW50ZXJmYWNlcy5cbiAgICovXG4gIGxpbmtQYXJ0aWFsRGVjbGFyYXRpb24oXG4gICAgICBjb25zdGFudFBvb2w6IENvbnN0YW50UG9vbCxcbiAgICAgIG1ldGFPYmo6IEFzdE9iamVjdDxSM1BhcnRpYWxEZWNsYXJhdGlvbiwgVEV4cHJlc3Npb24+KTogby5FeHByZXNzaW9uO1xufVxuIl19

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_linker_selector.d.ts

@@ -0,0 +1,81 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_linker_selector" />
+/**
+ * @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 { Range } from 'semver';
+import { AbsoluteFsPath } from '../../../../src/ngtsc/file_system';
+import { Logger } from '../../../../src/ngtsc/logging';
+import { LinkerEnvironment } from '../linker_environment';
+import { PartialLinker } from './partial_linker';
+export declare const ɵɵngDeclareDirective = "\u0275\u0275ngDeclareDirective";
+export declare const ɵɵngDeclareClassMetadata = "\u0275\u0275ngDeclareClassMetadata";
+export declare const ɵɵngDeclareComponent = "\u0275\u0275ngDeclareComponent";
+export declare const ɵɵngDeclareFactory = "\u0275\u0275ngDeclareFactory";
+export declare const ɵɵngDeclareInjectable = "\u0275\u0275ngDeclareInjectable";
+export declare const ɵɵngDeclareInjector = "\u0275\u0275ngDeclareInjector";
+export declare const ɵɵngDeclareNgModule = "\u0275\u0275ngDeclareNgModule";
+export declare const ɵɵngDeclarePipe = "\u0275\u0275ngDeclarePipe";
+export declare const declarationFunctions: string[];
+export interface LinkerRange<TExpression> {
+    range: Range;
+    linker: PartialLinker<TExpression>;
+}
+/**
+ * Create a mapping between partial-declaration call name and collections of partial-linkers.
+ *
+ * Each collection of partial-linkers will contain a version range that will be matched against the
+ * `minVersion` of the partial-declaration. (Additionally, a partial-linker may modify its behaviour
+ * internally based on the `version` property of the declaration.)
+ *
+ * Versions should be sorted in ascending order. The most recent partial-linker will be used as the
+ * fallback linker if none of the other version ranges match. For example:
+ *
+ * ```
+ * {range: getRange('<=', '13.0.0'), linker PartialDirectiveLinkerVersion2(...) },
+ * {range: getRange('<=', '13.1.0'), linker PartialDirectiveLinkerVersion3(...) },
+ * {range: getRange('<=', '14.0.0'), linker PartialDirectiveLinkerVersion4(...) },
+ * {range: LATEST_VERSION_RANGE, linker: new PartialDirectiveLinkerVersion1(...)},
+ * ```
+ *
+ * If the `LATEST_VERSION_RANGE` is `<=15.0.0` then the fallback linker would be
+ * `PartialDirectiveLinkerVersion1` for any version greater than `15.0.0`.
+ *
+ * When there is a change to a declaration interface that requires a new partial-linker, the
+ * `minVersion` of the partial-declaration should be updated, the new linker implementation should
+ * be added to the end of the collection, and the version of the previous linker should be updated.
+ */
+export declare function createLinkerMap<TStatement, TExpression>(environment: LinkerEnvironment<TStatement, TExpression>, sourceUrl: AbsoluteFsPath, code: string): Map<string, LinkerRange<TExpression>[]>;
+/**
+ * A helper that selects the appropriate `PartialLinker` for a given declaration.
+ *
+ * The selection is made from a database of linker instances, chosen if their given semver range
+ * satisfies the `minVersion` of the partial declaration to be linked.
+ *
+ * Note that the ranges are checked in order, and the first matching range will be selected. So
+ * ranges should be most restrictive first. In practice, since ranges are always `<=X.Y.Z` this
+ * means that ranges should be in ascending order.
+ *
+ * Note that any "pre-release" versions are stripped from ranges. Therefore if a `minVersion` is
+ * `11.1.0-next.1` then this would match `11.1.0-next.2` and also `12.0.0-next.1`. (This is
+ * different to standard semver range checking, where pre-release versions do not cross full version
+ * boundaries.)
+ */
+export declare class PartialLinkerSelector<TExpression> {
+    private readonly linkers;
+    private readonly logger;
+    private readonly unknownDeclarationVersionHandling;
+    constructor(linkers: Map<string, LinkerRange<TExpression>[]>, logger: Logger, unknownDeclarationVersionHandling: 'ignore' | 'warn' | 'error');
+    /**
+     * Returns true if there are `PartialLinker` classes that can handle functions with this name.
+     */
+    supportsDeclaration(functionName: string): boolean;
+    /**
+     * Returns the `PartialLinker` that can handle functions with the given name and version.
+     * Throws an error if there is none.
+     */
+    getLinker(functionName: string, minVersion: string, version: string): PartialLinker<TExpression>;
+}

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_ng_module_linker_1.d.ts

@@ -0,0 +1,33 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_ng_module_linker_1" />
+/**
+ * @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 { ConstantPool, R3DeclareNgModuleMetadata, R3NgModuleMetadata, R3PartialDeclaration } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { AstObject } from '../../ast/ast_value';
+import { PartialLinker } from './partial_linker';
+/**
+ * A `PartialLinker` that is designed to process `ɵɵngDeclareNgModule()` call expressions.
+ */
+export declare class PartialNgModuleLinkerVersion1<TExpression> implements PartialLinker<TExpression> {
+    /**
+     * If true then emit the additional declarations, imports, exports, etc in the NgModule
+     * definition. These are only used by JIT compilation.
+     */
+    private emitInline;
+    constructor(
+    /**
+     * If true then emit the additional declarations, imports, exports, etc in the NgModule
+     * definition. These are only used by JIT compilation.
+     */
+    emitInline: boolean);
+    linkPartialDeclaration(constantPool: ConstantPool, metaObj: AstObject<R3PartialDeclaration, TExpression>): o.Expression;
+}
+/**
+ * Derives the `R3NgModuleMetadata` structure from the AST object.
+ */
+export declare function toR3NgModuleMeta<TExpression>(metaObj: AstObject<R3DeclareNgModuleMetadata, TExpression>, emitInline: boolean): R3NgModuleMetadata;

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_pipe_linker_1.d.ts

@@ -0,0 +1,23 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_pipe_linker_1" />
+/**
+ * @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 { ConstantPool, R3DeclarePipeMetadata, R3PartialDeclaration, R3PipeMetadata } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { AstObject } from '../../ast/ast_value';
+import { PartialLinker } from './partial_linker';
+/**
+ * A `PartialLinker` that is designed to process `ɵɵngDeclarePipe()` call expressions.
+ */
+export declare class PartialPipeLinkerVersion1<TExpression> implements PartialLinker<TExpression> {
+    constructor();
+    linkPartialDeclaration(constantPool: ConstantPool, metaObj: AstObject<R3PartialDeclaration, TExpression>): o.Expression;
+}
+/**
+ * Derives the `R3PipeMetadata` structure from the AST object.
+ */
+export declare function toR3PipeMeta<TExpression>(metaObj: AstObject<R3DeclarePipeMetadata, TExpression>): R3PipeMetadata;

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_pipe_linker_1.js

@@ -0,0 +1,59 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/partial_linkers/partial_pipe_linker_1", ["require", "exports", "@angular/compiler", "@angular/compiler-cli/linker/src/fatal_linker_error", "@angular/compiler-cli/linker/src/file_linker/partial_linkers/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.toR3PipeMeta = exports.PartialPipeLinkerVersion1 = void 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
+     */
+    var compiler_1 = require("@angular/compiler");
+    var fatal_linker_error_1 = require("@angular/compiler-cli/linker/src/fatal_linker_error");
+    var util_1 = require("@angular/compiler-cli/linker/src/file_linker/partial_linkers/util");
+    /**
+     * A `PartialLinker` that is designed to process `ɵɵngDeclarePipe()` call expressions.
+     */
+    var PartialPipeLinkerVersion1 = /** @class */ (function () {
+        function PartialPipeLinkerVersion1() {
+        }
+        PartialPipeLinkerVersion1.prototype.linkPartialDeclaration = function (constantPool, metaObj) {
+            var meta = toR3PipeMeta(metaObj);
+            var def = compiler_1.compilePipeFromMetadata(meta);
+            return def.expression;
+        };
+        return PartialPipeLinkerVersion1;
+    }());
+    exports.PartialPipeLinkerVersion1 = PartialPipeLinkerVersion1;
+    /**
+     * Derives the `R3PipeMetadata` structure from the AST object.
+     */
+    function toR3PipeMeta(metaObj) {
+        var typeExpr = metaObj.getValue('type');
+        var typeName = typeExpr.getSymbolName();
+        if (typeName === null) {
+            throw new fatal_linker_error_1.FatalLinkerError(typeExpr.expression, 'Unsupported type, its name could not be determined');
+        }
+        var pure = metaObj.has('pure') ? metaObj.getBoolean('pure') : true;
+        return {
+            name: typeName,
+            type: util_1.wrapReference(typeExpr.getOpaque()),
+            internalType: metaObj.getOpaque('type'),
+            typeArgumentCount: 0,
+            deps: null,
+            pipeName: metaObj.getString('name'),
+            pure: pure,
+        };
+    }
+    exports.toR3PipeMeta = toR3PipeMeta;
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/src/file_linker/partial_linkers/util.d.ts

@@ -0,0 +1,31 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/partial_linkers/util" />
+/**
+ * @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 { R3DeclareDependencyMetadata, R3DependencyMetadata, R3ProviderExpression, R3Reference } from '@angular/compiler';
+import * as o from '@angular/compiler/src/output/output_ast';
+import { AstObject, AstValue } from '../../ast/ast_value';
+export declare function wrapReference<TExpression>(wrapped: o.WrappedNodeExpr<TExpression>): R3Reference;
+/**
+ * Parses the value of an enum from the AST value's symbol name.
+ */
+export declare function parseEnum<TExpression, TEnum>(value: AstValue<unknown, TExpression>, Enum: TEnum): TEnum[keyof TEnum];
+/**
+ * Parse a dependency structure from an AST object.
+ */
+export declare function getDependency<TExpression>(depObj: AstObject<R3DeclareDependencyMetadata, TExpression>): R3DependencyMetadata;
+/**
+ * Return an `R3ProviderExpression` that represents either the extracted type reference expression
+ * from a `forwardRef` function call, or the type itself.
+ *
+ * For example, the expression `forwardRef(function() { return FooDir; })` returns `FooDir`. Note
+ * that this expression is required to be wrapped in a closure, as otherwise the forward reference
+ * would be resolved before initialization.
+ *
+ * If there is no forwardRef call expression then we just return the opaque type.
+ */
+export declare function extractForwardRef<TExpression>(expr: AstValue<unknown, TExpression>): R3ProviderExpression<o.WrappedNodeExpr<TExpression>>;

node_modules/@angular/compiler-cli/linker/src/file_linker/translator.d.ts

@@ -0,0 +1,26 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/file_linker/translator" />
+/**
+ * @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 o from '@angular/compiler';
+import { AstFactory, ImportGenerator, TranslatorOptions } from '@angular/compiler-cli/src/ngtsc/translator';
+/**
+ * Generic translator helper class, which exposes methods for translating expressions and
+ * statements.
+ */
+export declare class Translator<TStatement, TExpression> {
+    private factory;
+    constructor(factory: AstFactory<TStatement, TExpression>);
+    /**
+     * Translate the given output AST in the context of an expression.
+     */
+    translateExpression(expression: o.Expression, imports: ImportGenerator<TExpression>, options?: TranslatorOptions<TExpression>): TExpression;
+    /**
+     * Translate the given output AST in the context of a statement.
+     */
+    translateStatement(statement: o.Statement, imports: ImportGenerator<TExpression>, options?: TranslatorOptions<TExpression>): TStatement;
+}

node_modules/@angular/compiler-cli/linker/src/file_linker/translator.js

@@ -0,0 +1,40 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/file_linker/translator", ["require", "exports", "@angular/compiler-cli/src/ngtsc/translator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Translator = void 0;
+    var translator_1 = require("@angular/compiler-cli/src/ngtsc/translator");
+    /**
+     * Generic translator helper class, which exposes methods for translating expressions and
+     * statements.
+     */
+    var Translator = /** @class */ (function () {
+        function Translator(factory) {
+            this.factory = factory;
+        }
+        /**
+         * Translate the given output AST in the context of an expression.
+         */
+        Translator.prototype.translateExpression = function (expression, imports, options) {
+            if (options === void 0) { options = {}; }
+            return expression.visitExpression(new translator_1.ExpressionTranslatorVisitor(this.factory, imports, options), new translator_1.Context(false));
+        };
+        /**
+         * Translate the given output AST in the context of a statement.
+         */
+        Translator.prototype.translateStatement = function (statement, imports, options) {
+            if (options === void 0) { options = {}; }
+            return statement.visitStatement(new translator_1.ExpressionTranslatorVisitor(this.factory, imports, options), new translator_1.Context(true));
+        };
+        return Translator;
+    }());
+    exports.Translator = Translator;
+});
+//# sourceMappingURL=data:application/json;base64,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

node_modules/@angular/compiler-cli/linker/src/linker_import_generator.d.ts

@@ -0,0 +1,24 @@
+/// <amd-module name="@angular/compiler-cli/linker/src/linker_import_generator" />
+/**
+ * @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 { ImportGenerator, NamedImport } from '../../src/ngtsc/translator';
+/**
+ * A class that is used to generate imports when translating from Angular Output AST to an AST to
+ * render, such as Babel.
+ *
+ * Note that, in the linker, there can only be imports from `@angular/core` and that these imports
+ * must be achieved by property access on an `ng` namespace identifer, which is passed in via the
+ * constructor.
+ */
+export declare class LinkerImportGenerator<TExpression> implements ImportGenerator<TExpression> {
+    private ngImport;
+    constructor(ngImport: TExpression);
+    generateNamespaceImport(moduleName: string): TExpression;
+    generateNamedImport(moduleName: string, originalSymbol: string): NamedImport<TExpression>;
+    private assertModuleName;
+}

node_modules/@angular/compiler-cli/linker/src/linker_import_generator.js

@@ -0,0 +1,43 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define("@angular/compiler-cli/linker/src/linker_import_generator", ["require", "exports", "@angular/compiler-cli/linker/src/fatal_linker_error"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LinkerImportGenerator = void 0;
+    var fatal_linker_error_1 = require("@angular/compiler-cli/linker/src/fatal_linker_error");
+    /**
+     * A class that is used to generate imports when translating from Angular Output AST to an AST to
+     * render, such as Babel.
+     *
+     * Note that, in the linker, there can only be imports from `@angular/core` and that these imports
+     * must be achieved by property access on an `ng` namespace identifer, which is passed in via the
+     * constructor.
+     */
+    var LinkerImportGenerator = /** @class */ (function () {
+        function LinkerImportGenerator(ngImport) {
+            this.ngImport = ngImport;
+        }
+        LinkerImportGenerator.prototype.generateNamespaceImport = function (moduleName) {
+            this.assertModuleName(moduleName);
+            return this.ngImport;
+        };
+        LinkerImportGenerator.prototype.generateNamedImport = function (moduleName, originalSymbol) {
+            this.assertModuleName(moduleName);
+            return { moduleImport: this.ngImport, symbol: originalSymbol };
+        };
+        LinkerImportGenerator.prototype.assertModuleName = function (moduleName) {
+            if (moduleName !== '@angular/core') {
+                throw new fatal_linker_error_1.FatalLinkerError(this.ngImport, "Unable to import from anything other than '@angular/core'");
+            }
+        };
+        return LinkerImportGenerator;
+    }());
+    exports.LinkerImportGenerator = LinkerImportGenerator;
+});
+//# sourceMappingURL=data:application/json;base64,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