@angular/core 13.1.0-next.2 → 13.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "13.1.0-next.2",
+  "version": "13.1.2",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",

package/schematics/migrations/entry-components/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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/core/schematics/migrations/entry-components" />
+import { Rule } from '@angular-devkit/schematics';
+/** Migration that removes `entryComponents` usages. */
+export default function (): Rule;

package/schematics/migrations/entry-components/index.js

@@ -0,0 +1,71 @@
+/**
+ * @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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(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/core/schematics/migrations/entry-components", ["require", "exports", "@angular-devkit/schematics", "path", "typescript", "@angular/core/schematics/utils/project_tsconfig_paths", "@angular/core/schematics/utils/typescript/compiler_host", "@angular/core/schematics/migrations/entry-components/util"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const schematics_1 = require("@angular-devkit/schematics");
+    const path_1 = require("path");
+    const typescript_1 = __importDefault(require("typescript"));
+    const project_tsconfig_paths_1 = require("@angular/core/schematics/utils/project_tsconfig_paths");
+    const compiler_host_1 = require("@angular/core/schematics/utils/typescript/compiler_host");
+    const util_1 = require("@angular/core/schematics/migrations/entry-components/util");
+    /** Migration that removes `entryComponents` usages. */
+    function default_1() {
+        return (tree) => __awaiter(this, void 0, void 0, function* () {
+            const { buildPaths, testPaths } = yield (0, project_tsconfig_paths_1.getProjectTsConfigPaths)(tree);
+            const basePath = process.cwd();
+            const allPaths = [...buildPaths, ...testPaths];
+            if (!allPaths.length) {
+                throw new schematics_1.SchematicsException('Could not find any tsconfig file. Cannot remove `entryComponents`.');
+            }
+            for (const tsconfigPath of allPaths) {
+                runEntryComponentsMigration(tree, tsconfigPath, basePath);
+            }
+        });
+    }
+    exports.default = default_1;
+    function runEntryComponentsMigration(tree, tsconfigPath, basePath) {
+        const { program } = (0, compiler_host_1.createMigrationProgram)(tree, tsconfigPath, basePath);
+        const typeChecker = program.getTypeChecker();
+        const printer = typescript_1.default.createPrinter();
+        program.getSourceFiles()
+            .filter(sourceFile => (0, compiler_host_1.canMigrateFile)(basePath, sourceFile, program))
+            .forEach(sourceFile => {
+            const usages = (0, util_1.migrateEntryComponentsUsages)(typeChecker, printer, sourceFile);
+            if (usages.length > 0) {
+                const update = tree.beginUpdate((0, path_1.relative)(basePath, sourceFile.fileName));
+                usages.forEach(usage => {
+                    update.remove(usage.start, usage.length);
+                    update.insertRight(usage.start, usage.replacement);
+                });
+                tree.commitUpdate(update);
+            }
+        });
+    }
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations/entry-components/util.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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/core/schematics/migrations/entry-components/util" />
+import ts from 'typescript';
+/** Finds and migrates all Angular decorators that pass in `entryComponents`. */
+export declare function migrateEntryComponentsUsages(typeChecker: ts.TypeChecker, printer: ts.Printer, sourceFile: ts.SourceFile): {
+    start: number;
+    length: number;
+    end: number;
+    replacement: string;
+}[];

package/schematics/migrations/entry-components/util.js

@@ -0,0 +1,57 @@
+/**
+ * @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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(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/core/schematics/migrations/entry-components/util", ["require", "exports", "typescript", "@angular/core/schematics/utils/typescript/decorators"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.migrateEntryComponentsUsages = void 0;
+    const typescript_1 = __importDefault(require("typescript"));
+    const decorators_1 = require("@angular/core/schematics/utils/typescript/decorators");
+    /** Finds and migrates all Angular decorators that pass in `entryComponents`. */
+    function migrateEntryComponentsUsages(typeChecker, printer, sourceFile) {
+        const results = [];
+        sourceFile.forEachChild(function walk(node) {
+            if (typescript_1.default.isDecorator(node) && typescript_1.default.isCallExpression(node.expression) &&
+                node.expression.arguments.length === 1 &&
+                typescript_1.default.isObjectLiteralExpression(node.expression.arguments[0])) {
+                const analysis = (0, decorators_1.getCallDecoratorImport)(typeChecker, node);
+                if (analysis && analysis.importModule === '@angular/core' &&
+                    (analysis.name === 'Component' || analysis.name === 'NgModule')) {
+                    const literal = node.expression.arguments[0];
+                    const entryComponentsProp = literal.properties.find(property => typescript_1.default.isPropertyAssignment(property) && typescript_1.default.isIdentifier(property.name) &&
+                        property.name.text === 'entryComponents');
+                    if (entryComponentsProp) {
+                        const replacementNode = typescript_1.default.updateObjectLiteral(literal, literal.properties.filter(prop => prop !== entryComponentsProp));
+                        results.push({
+                            start: literal.getStart(),
+                            length: literal.getWidth(),
+                            end: literal.getEnd(),
+                            replacement: printer.printNode(typescript_1.default.EmitHint.Unspecified, replacementNode, sourceFile)
+                        });
+                    }
+                }
+            }
+            node.forEachChild(walk);
+        });
+        // Sort the operations in reverse order in order to avoid
+        // issues when migrating multiple usages within the same file.
+        return results.sort((a, b) => b.start - a.start);
+    }
+    exports.migrateEntryComponentsUsages = migrateEntryComponentsUsages;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/schematics/migrations.json

@@ -9,6 +9,16 @@
       "version": "13.0.0-beta",
       "description": "In Angular version 13, the `teardown` flag in `TestBed` will be enabled by default. This migration automatically opts out existing apps from the new teardown behavior.",
       "factory": "./migrations/testbed-teardown/index"
+    },
+    "migration-v13.1-entry-components": {
+      "version": "13.1.0-beta",
+      "description": "As of Angular version 13, `entryComponents` are no longer necessary.",
+      "factory": "./migrations/entry-components/index"
+    },
+    "migration-v14-entry-components": {
+      "version": "14.0.0-beta",
+      "description": "As of Angular version 13, `entryComponents` are no longer necessary.",
+      "factory": "./migrations/entry-components/index"
     }
   }
 }

package/schematics/utils/import_manager.js

@@ -22,6 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     exports.ImportManager = void 0;
     const path_1 = require("path");
     const typescript_1 = __importDefault(require("typescript"));
+    const PARSED_TS_VERSION = parseFloat(typescript_1.default.versionMajorMinor);
     /**
      * Import manager that can be used to add TypeScript imports to given source
      * files. The manager ensures that multiple transformations are applied properly
@@ -124,7 +125,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
                 const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName);
                 const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;
                 identifier = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;
-                newImport = typescript_1.default.createImportDeclaration(undefined, undefined, typescript_1.default.createImportClause(undefined, typescript_1.default.createNamedImports([typescript_1.default.createImportSpecifier(needsGeneratedUniqueName ? propertyIdentifier : undefined, identifier)])), typescript_1.default.createStringLiteral(moduleName));
+                newImport = typescript_1.default.createImportDeclaration(undefined, undefined, typescript_1.default.createImportClause(undefined, typescript_1.default.createNamedImports([createImportSpecifier(needsGeneratedUniqueName ? propertyIdentifier : undefined, identifier)])), typescript_1.default.createStringLiteral(moduleName));
             }
             else {
                 identifier = this._getUniqueIdentifier(sourceFile, 'defaultExport');
@@ -152,7 +153,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
                 const sourceFile = importDecl.getSourceFile();
                 const recorder = this.getUpdateRecorder(sourceFile);
                 const namedBindings = importDecl.importClause.namedBindings;
-                const newNamedBindings = typescript_1.default.updateNamedImports(namedBindings, namedBindings.elements.concat(expressions.map(({ propertyName, importName }) => typescript_1.default.createImportSpecifier(propertyName, importName))));
+                const newNamedBindings = typescript_1.default.updateNamedImports(namedBindings, namedBindings.elements.concat(expressions.map(({ propertyName, importName }) => createImportSpecifier(propertyName, importName))));
                 const newNamedBindingsText = this.printer.printNode(typescript_1.default.EmitHint.Unspecified, newNamedBindings, sourceFile);
                 recorder.updateExistingImport(namedBindings, newNamedBindingsText);
             });
@@ -210,5 +211,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         }
     }
     exports.ImportManager = ImportManager;
+    /**
+     * Backwards-compatible version of `ts.createImportSpecifier`
+     * to handle a breaking change between 4.4 and 4.5.
+     */
+    function createImportSpecifier(propertyName, name, isTypeOnly = false) {
+        return PARSED_TS_VERSION > 4.4 ? typescript_1.default.createImportSpecifier(isTypeOnly, propertyName, name) :
+            // TODO(crisbeto): backwards-compatibility layer for TS 4.4.
+            // Should be cleaned up when we drop support for it.
+            typescript_1.default.createImportSpecifier(propertyName, name);
+    }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import_manager.js","sourceRoot":"","sources":["../../../../../../../packages/core/schematics/utils/import_manager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {dirname, resolve} from 'path';\nimport ts from 'typescript';\n\n/** Update recorder for managing imports. */\nexport interface ImportManagerUpdateRecorder {\n  addNewImport(start: number, importText: string): void;\n  updateExistingImport(namedBindings: ts.NamedImports, newNamedBindings: string): void;\n}\n\n/**\n * Import manager that can be used to add TypeScript imports to given source\n * files. The manager ensures that multiple transformations are applied properly\n * without shifted offsets and that similar existing import declarations are re-used.\n */\nexport class ImportManager {\n  /** Map of import declarations that need to be updated to include the given symbols. */\n  private updatedImports =\n      new Map<ts.ImportDeclaration, {propertyName?: ts.Identifier, importName: ts.Identifier}[]>();\n  /** Map of source-files and their previously used identifier names. */\n  private usedIdentifierNames = new Map<ts.SourceFile, string[]>();\n  /**\n   * Array of previously resolved symbol imports. Cache can be re-used to return\n   * the same identifier without checking the source-file again.\n   */\n  private importCache: {\n    sourceFile: ts.SourceFile,\n    symbolName: string|null,\n    moduleName: string,\n    identifier: ts.Identifier\n  }[] = [];\n\n  constructor(\n      private getUpdateRecorder: (sf: ts.SourceFile) => ImportManagerUpdateRecorder,\n      private printer: ts.Printer) {}\n\n  /**\n   * Adds an import to the given source-file and returns the TypeScript\n   * identifier that can be used to access the newly imported symbol.\n   */\n  addImportToSourceFile(\n      sourceFile: ts.SourceFile, symbolName: string|null, moduleName: string,\n      typeImport = false): ts.Expression {\n    const sourceDir = dirname(sourceFile.fileName);\n    let importStartIndex = 0;\n    let existingImport: ts.ImportDeclaration|null = null;\n\n    // In case the given import has been already generated previously, we just return\n    // the previous generated identifier in order to avoid duplicate generated imports.\n    const cachedImport = this.importCache.find(\n        c => c.sourceFile === sourceFile && c.symbolName === symbolName &&\n            c.moduleName === moduleName);\n    if (cachedImport) {\n      return cachedImport.identifier;\n    }\n\n    // Walk through all source-file top-level statements and search for import declarations\n    // that already match the specified \"moduleName\" and can be updated to import the\n    // given symbol. If no matching import can be found, the last import in the source-file\n    // will be used as starting point for a new import that will be generated.\n    for (let i = sourceFile.statements.length - 1; i >= 0; i--) {\n      const statement = sourceFile.statements[i];\n\n      if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) ||\n          !statement.importClause) {\n        continue;\n      }\n\n      if (importStartIndex === 0) {\n        importStartIndex = this._getEndPositionOfNode(statement);\n      }\n\n      const moduleSpecifier = statement.moduleSpecifier.text;\n\n      if (moduleSpecifier.startsWith('.') &&\n              resolve(sourceDir, moduleSpecifier) !== resolve(sourceDir, moduleName) ||\n          moduleSpecifier !== moduleName) {\n        continue;\n      }\n\n      if (statement.importClause.namedBindings) {\n        const namedBindings = statement.importClause.namedBindings;\n\n        // In case a \"Type\" symbol is imported, we can't use namespace imports\n        // because these only export symbols available at runtime (no types)\n        if (ts.isNamespaceImport(namedBindings) && !typeImport) {\n          return ts.createPropertyAccess(\n              ts.createIdentifier(namedBindings.name.text),\n              ts.createIdentifier(symbolName || 'default'));\n        } else if (ts.isNamedImports(namedBindings) && symbolName) {\n          const existingElement = namedBindings.elements.find(\n              e =>\n                  e.propertyName ? e.propertyName.text === symbolName : e.name.text === symbolName);\n\n          if (existingElement) {\n            return ts.createIdentifier(existingElement.name.text);\n          }\n\n          // In case the symbol could not be found in an existing import, we\n          // keep track of the import declaration as it can be updated to include\n          // the specified symbol name without having to create a new import.\n          existingImport = statement;\n        }\n      } else if (statement.importClause.name && !symbolName) {\n        return ts.createIdentifier(statement.importClause.name.text);\n      }\n    }\n\n    if (existingImport) {\n      const propertyIdentifier = ts.createIdentifier(symbolName!);\n      const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName!);\n      const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;\n      const importName = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;\n\n      // Since it can happen that multiple classes need to be imported within the\n      // specified source file and we want to add the identifiers to the existing\n      // import declaration, we need to keep track of the updated import declarations.\n      // We can't directly update the import declaration for each identifier as this\n      // would throw off the recorder offsets. We need to keep track of the new identifiers\n      // for the import and perform the import transformation as batches per source-file.\n      this.updatedImports.set(\n          existingImport, (this.updatedImports.get(existingImport) || []).concat({\n            propertyName: needsGeneratedUniqueName ? propertyIdentifier : undefined,\n            importName: importName,\n          }));\n\n      // Keep track of all updated imports so that we don't generate duplicate\n      // similar imports as these can't be statically analyzed in the source-file yet.\n      this.importCache.push({sourceFile, moduleName, symbolName, identifier: importName});\n\n      return importName;\n    }\n\n    let identifier: ts.Identifier|null = null;\n    let newImport: ts.ImportDeclaration|null = null;\n\n    if (symbolName) {\n      const propertyIdentifier = ts.createIdentifier(symbolName);\n      const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName);\n      const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;\n      identifier = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;\n\n      newImport = ts.createImportDeclaration(\n          undefined, undefined,\n          ts.createImportClause(\n              undefined,\n              ts.createNamedImports([ts.createImportSpecifier(\n                  needsGeneratedUniqueName ? propertyIdentifier : undefined, identifier)])),\n          ts.createStringLiteral(moduleName));\n    } else {\n      identifier = this._getUniqueIdentifier(sourceFile, 'defaultExport');\n      newImport = ts.createImportDeclaration(\n          undefined, undefined, ts.createImportClause(identifier, undefined),\n          ts.createStringLiteral(moduleName));\n    }\n\n    const newImportText = this.printer.printNode(ts.EmitHint.Unspecified, newImport, sourceFile);\n    // If the import is generated at the start of the source file, we want to add\n    // a new-line after the import. Otherwise if the import is generated after an\n    // existing import, we need to prepend a new-line so that the import is not on\n    // the same line as the existing import anchor.\n    this.getUpdateRecorder(sourceFile)\n        .addNewImport(\n            importStartIndex, importStartIndex === 0 ? `${newImportText}\\n` : `\\n${newImportText}`);\n\n    // Keep track of all generated imports so that we don't generate duplicate\n    // similar imports as these can't be statically analyzed in the source-file yet.\n    this.importCache.push({sourceFile, symbolName, moduleName, identifier});\n\n    return identifier;\n  }\n\n  /**\n   * Stores the collected import changes within the appropriate update recorders. The\n   * updated imports can only be updated *once* per source-file because previous updates\n   * could otherwise shift the source-file offsets.\n   */\n  recordChanges() {\n    this.updatedImports.forEach((expressions, importDecl) => {\n      const sourceFile = importDecl.getSourceFile();\n      const recorder = this.getUpdateRecorder(sourceFile);\n      const namedBindings = importDecl.importClause!.namedBindings as ts.NamedImports;\n      const newNamedBindings = ts.updateNamedImports(\n          namedBindings,\n          namedBindings.elements.concat(expressions.map(\n              ({propertyName, importName}) => ts.createImportSpecifier(propertyName, importName))));\n\n      const newNamedBindingsText =\n          this.printer.printNode(ts.EmitHint.Unspecified, newNamedBindings, sourceFile);\n      recorder.updateExistingImport(namedBindings, newNamedBindingsText);\n    });\n  }\n\n  /** Gets an unique identifier with a base name for the given source file. */\n  private _getUniqueIdentifier(sourceFile: ts.SourceFile, baseName: string): ts.Identifier {\n    if (this.isUniqueIdentifierName(sourceFile, baseName)) {\n      this._recordUsedIdentifier(sourceFile, baseName);\n      return ts.createIdentifier(baseName);\n    }\n\n    let name = null;\n    let counter = 1;\n    do {\n      name = `${baseName}_${counter++}`;\n    } while (!this.isUniqueIdentifierName(sourceFile, name));\n\n    this._recordUsedIdentifier(sourceFile, name!);\n    return ts.createIdentifier(name!);\n  }\n\n  /**\n   * Checks whether the specified identifier name is used within the given\n   * source file.\n   */\n  private isUniqueIdentifierName(sourceFile: ts.SourceFile, name: string) {\n    if (this.usedIdentifierNames.has(sourceFile) &&\n        this.usedIdentifierNames.get(sourceFile)!.indexOf(name) !== -1) {\n      return false;\n    }\n\n    // Walk through the source file and search for an identifier matching\n    // the given name. In that case, it's not guaranteed that this name\n    // is unique in the given declaration scope and we just return false.\n    const nodeQueue: ts.Node[] = [sourceFile];\n    while (nodeQueue.length) {\n      const node = nodeQueue.shift()!;\n      if (ts.isIdentifier(node) && node.text === name) {\n        return false;\n      }\n      nodeQueue.push(...node.getChildren());\n    }\n    return true;\n  }\n\n  private _recordUsedIdentifier(sourceFile: ts.SourceFile, identifierName: string) {\n    this.usedIdentifierNames.set(\n        sourceFile, (this.usedIdentifierNames.get(sourceFile) || []).concat(identifierName));\n  }\n\n  /**\n   * Determines the full end of a given node. By default the end position of a node is\n   * before all trailing comments. This could mean that generated imports shift comments.\n   */\n  private _getEndPositionOfNode(node: ts.Node) {\n    const nodeEndPos = node.getEnd();\n    const commentRanges = ts.getTrailingCommentRanges(node.getSourceFile().text, nodeEndPos);\n    if (!commentRanges || !commentRanges.length) {\n      return nodeEndPos;\n    }\n    return commentRanges[commentRanges.length - 1]!.end;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"import_manager.js","sourceRoot":"","sources":["../../../../../../../packages/core/schematics/utils/import_manager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {dirname, resolve} from 'path';\nimport ts from 'typescript';\n\nconst PARSED_TS_VERSION = parseFloat(ts.versionMajorMinor);\n\n/** Update recorder for managing imports. */\nexport interface ImportManagerUpdateRecorder {\n  addNewImport(start: number, importText: string): void;\n  updateExistingImport(namedBindings: ts.NamedImports, newNamedBindings: string): void;\n}\n\n/**\n * Import manager that can be used to add TypeScript imports to given source\n * files. The manager ensures that multiple transformations are applied properly\n * without shifted offsets and that similar existing import declarations are re-used.\n */\nexport class ImportManager {\n  /** Map of import declarations that need to be updated to include the given symbols. */\n  private updatedImports =\n      new Map<ts.ImportDeclaration, {propertyName?: ts.Identifier, importName: ts.Identifier}[]>();\n  /** Map of source-files and their previously used identifier names. */\n  private usedIdentifierNames = new Map<ts.SourceFile, string[]>();\n  /**\n   * Array of previously resolved symbol imports. Cache can be re-used to return\n   * the same identifier without checking the source-file again.\n   */\n  private importCache: {\n    sourceFile: ts.SourceFile,\n    symbolName: string|null,\n    moduleName: string,\n    identifier: ts.Identifier\n  }[] = [];\n\n  constructor(\n      private getUpdateRecorder: (sf: ts.SourceFile) => ImportManagerUpdateRecorder,\n      private printer: ts.Printer) {}\n\n  /**\n   * Adds an import to the given source-file and returns the TypeScript\n   * identifier that can be used to access the newly imported symbol.\n   */\n  addImportToSourceFile(\n      sourceFile: ts.SourceFile, symbolName: string|null, moduleName: string,\n      typeImport = false): ts.Expression {\n    const sourceDir = dirname(sourceFile.fileName);\n    let importStartIndex = 0;\n    let existingImport: ts.ImportDeclaration|null = null;\n\n    // In case the given import has been already generated previously, we just return\n    // the previous generated identifier in order to avoid duplicate generated imports.\n    const cachedImport = this.importCache.find(\n        c => c.sourceFile === sourceFile && c.symbolName === symbolName &&\n            c.moduleName === moduleName);\n    if (cachedImport) {\n      return cachedImport.identifier;\n    }\n\n    // Walk through all source-file top-level statements and search for import declarations\n    // that already match the specified \"moduleName\" and can be updated to import the\n    // given symbol. If no matching import can be found, the last import in the source-file\n    // will be used as starting point for a new import that will be generated.\n    for (let i = sourceFile.statements.length - 1; i >= 0; i--) {\n      const statement = sourceFile.statements[i];\n\n      if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) ||\n          !statement.importClause) {\n        continue;\n      }\n\n      if (importStartIndex === 0) {\n        importStartIndex = this._getEndPositionOfNode(statement);\n      }\n\n      const moduleSpecifier = statement.moduleSpecifier.text;\n\n      if (moduleSpecifier.startsWith('.') &&\n              resolve(sourceDir, moduleSpecifier) !== resolve(sourceDir, moduleName) ||\n          moduleSpecifier !== moduleName) {\n        continue;\n      }\n\n      if (statement.importClause.namedBindings) {\n        const namedBindings = statement.importClause.namedBindings;\n\n        // In case a \"Type\" symbol is imported, we can't use namespace imports\n        // because these only export symbols available at runtime (no types)\n        if (ts.isNamespaceImport(namedBindings) && !typeImport) {\n          return ts.createPropertyAccess(\n              ts.createIdentifier(namedBindings.name.text),\n              ts.createIdentifier(symbolName || 'default'));\n        } else if (ts.isNamedImports(namedBindings) && symbolName) {\n          const existingElement = namedBindings.elements.find(\n              e =>\n                  e.propertyName ? e.propertyName.text === symbolName : e.name.text === symbolName);\n\n          if (existingElement) {\n            return ts.createIdentifier(existingElement.name.text);\n          }\n\n          // In case the symbol could not be found in an existing import, we\n          // keep track of the import declaration as it can be updated to include\n          // the specified symbol name without having to create a new import.\n          existingImport = statement;\n        }\n      } else if (statement.importClause.name && !symbolName) {\n        return ts.createIdentifier(statement.importClause.name.text);\n      }\n    }\n\n    if (existingImport) {\n      const propertyIdentifier = ts.createIdentifier(symbolName!);\n      const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName!);\n      const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;\n      const importName = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;\n\n      // Since it can happen that multiple classes need to be imported within the\n      // specified source file and we want to add the identifiers to the existing\n      // import declaration, we need to keep track of the updated import declarations.\n      // We can't directly update the import declaration for each identifier as this\n      // would throw off the recorder offsets. We need to keep track of the new identifiers\n      // for the import and perform the import transformation as batches per source-file.\n      this.updatedImports.set(\n          existingImport, (this.updatedImports.get(existingImport) || []).concat({\n            propertyName: needsGeneratedUniqueName ? propertyIdentifier : undefined,\n            importName: importName,\n          }));\n\n      // Keep track of all updated imports so that we don't generate duplicate\n      // similar imports as these can't be statically analyzed in the source-file yet.\n      this.importCache.push({sourceFile, moduleName, symbolName, identifier: importName});\n\n      return importName;\n    }\n\n    let identifier: ts.Identifier|null = null;\n    let newImport: ts.ImportDeclaration|null = null;\n\n    if (symbolName) {\n      const propertyIdentifier = ts.createIdentifier(symbolName);\n      const generatedUniqueIdentifier = this._getUniqueIdentifier(sourceFile, symbolName);\n      const needsGeneratedUniqueName = generatedUniqueIdentifier.text !== symbolName;\n      identifier = needsGeneratedUniqueName ? generatedUniqueIdentifier : propertyIdentifier;\n\n      newImport = ts.createImportDeclaration(\n          undefined, undefined,\n          ts.createImportClause(\n              undefined,\n              ts.createNamedImports([createImportSpecifier(\n                  needsGeneratedUniqueName ? propertyIdentifier : undefined, identifier)])),\n          ts.createStringLiteral(moduleName));\n    } else {\n      identifier = this._getUniqueIdentifier(sourceFile, 'defaultExport');\n      newImport = ts.createImportDeclaration(\n          undefined, undefined, ts.createImportClause(identifier, undefined),\n          ts.createStringLiteral(moduleName));\n    }\n\n    const newImportText = this.printer.printNode(ts.EmitHint.Unspecified, newImport, sourceFile);\n    // If the import is generated at the start of the source file, we want to add\n    // a new-line after the import. Otherwise if the import is generated after an\n    // existing import, we need to prepend a new-line so that the import is not on\n    // the same line as the existing import anchor.\n    this.getUpdateRecorder(sourceFile)\n        .addNewImport(\n            importStartIndex, importStartIndex === 0 ? `${newImportText}\\n` : `\\n${newImportText}`);\n\n    // Keep track of all generated imports so that we don't generate duplicate\n    // similar imports as these can't be statically analyzed in the source-file yet.\n    this.importCache.push({sourceFile, symbolName, moduleName, identifier});\n\n    return identifier;\n  }\n\n  /**\n   * Stores the collected import changes within the appropriate update recorders. The\n   * updated imports can only be updated *once* per source-file because previous updates\n   * could otherwise shift the source-file offsets.\n   */\n  recordChanges() {\n    this.updatedImports.forEach((expressions, importDecl) => {\n      const sourceFile = importDecl.getSourceFile();\n      const recorder = this.getUpdateRecorder(sourceFile);\n      const namedBindings = importDecl.importClause!.namedBindings as ts.NamedImports;\n      const newNamedBindings = ts.updateNamedImports(\n          namedBindings,\n          namedBindings.elements.concat(expressions.map(\n              ({propertyName, importName}) => createImportSpecifier(propertyName, importName))));\n\n      const newNamedBindingsText =\n          this.printer.printNode(ts.EmitHint.Unspecified, newNamedBindings, sourceFile);\n      recorder.updateExistingImport(namedBindings, newNamedBindingsText);\n    });\n  }\n\n  /** Gets an unique identifier with a base name for the given source file. */\n  private _getUniqueIdentifier(sourceFile: ts.SourceFile, baseName: string): ts.Identifier {\n    if (this.isUniqueIdentifierName(sourceFile, baseName)) {\n      this._recordUsedIdentifier(sourceFile, baseName);\n      return ts.createIdentifier(baseName);\n    }\n\n    let name = null;\n    let counter = 1;\n    do {\n      name = `${baseName}_${counter++}`;\n    } while (!this.isUniqueIdentifierName(sourceFile, name));\n\n    this._recordUsedIdentifier(sourceFile, name!);\n    return ts.createIdentifier(name!);\n  }\n\n  /**\n   * Checks whether the specified identifier name is used within the given\n   * source file.\n   */\n  private isUniqueIdentifierName(sourceFile: ts.SourceFile, name: string) {\n    if (this.usedIdentifierNames.has(sourceFile) &&\n        this.usedIdentifierNames.get(sourceFile)!.indexOf(name) !== -1) {\n      return false;\n    }\n\n    // Walk through the source file and search for an identifier matching\n    // the given name. In that case, it's not guaranteed that this name\n    // is unique in the given declaration scope and we just return false.\n    const nodeQueue: ts.Node[] = [sourceFile];\n    while (nodeQueue.length) {\n      const node = nodeQueue.shift()!;\n      if (ts.isIdentifier(node) && node.text === name) {\n        return false;\n      }\n      nodeQueue.push(...node.getChildren());\n    }\n    return true;\n  }\n\n  private _recordUsedIdentifier(sourceFile: ts.SourceFile, identifierName: string) {\n    this.usedIdentifierNames.set(\n        sourceFile, (this.usedIdentifierNames.get(sourceFile) || []).concat(identifierName));\n  }\n\n  /**\n   * Determines the full end of a given node. By default the end position of a node is\n   * before all trailing comments. This could mean that generated imports shift comments.\n   */\n  private _getEndPositionOfNode(node: ts.Node) {\n    const nodeEndPos = node.getEnd();\n    const commentRanges = ts.getTrailingCommentRanges(node.getSourceFile().text, nodeEndPos);\n    if (!commentRanges || !commentRanges.length) {\n      return nodeEndPos;\n    }\n    return commentRanges[commentRanges.length - 1]!.end;\n  }\n}\n\n\n/**\n * Backwards-compatible version of `ts.createImportSpecifier`\n * to handle a breaking change between 4.4 and 4.5.\n */\nfunction createImportSpecifier(\n    propertyName: ts.Identifier|undefined, name: ts.Identifier,\n    isTypeOnly = false): ts.ImportSpecifier {\n  return PARSED_TS_VERSION > 4.4 ? ts.createImportSpecifier(isTypeOnly, propertyName, name) :\n                                   // TODO(crisbeto): backwards-compatibility layer for TS 4.4.\n                                   // Should be cleaned up when we drop support for it.\n                                   (ts.createImportSpecifier as any)(propertyName, name);\n}\n"]}

package/schematics/utils/typescript/imports.js

@@ -21,6 +21,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.findImportSpecifier = exports.replaceImport = exports.getImportSpecifier = exports.getImportOfIdentifier = void 0;
     const typescript_1 = __importDefault(require("typescript"));
+    const PARSED_TS_VERSION = parseFloat(typescript_1.default.versionMajorMinor);
     /** Gets import information about the specified identifier by using the Type checker. */
     function getImportOfIdentifier(typeChecker, node) {
         const symbol = typeChecker.getSymbolAtLocation(node);
@@ -91,11 +92,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         if (!existingImportNode) {
             return node;
         }
+        const importPropertyName = existingImportNode.propertyName ? typescript_1.default.createIdentifier(newImportName) : undefined;
+        const importName = existingImportNode.propertyName ? existingImportNode.name :
+            typescript_1.default.createIdentifier(newImportName);
         return typescript_1.default.updateNamedImports(node, [
             ...node.elements.filter(current => current !== existingImportNode),
             // Create a new import while trying to preserve the alias of the old one.
-            typescript_1.default.createImportSpecifier(existingImportNode.propertyName ? typescript_1.default.createIdentifier(newImportName) : undefined, existingImportNode.propertyName ? existingImportNode.name :
-                typescript_1.default.createIdentifier(newImportName))
+            PARSED_TS_VERSION > 4.4 ? typescript_1.default.createImportSpecifier(false, importPropertyName, importName) :
+                // TODO(crisbeto): backwards-compatibility layer for TS 4.4.
+                // Should be cleaned up when we drop support for it.
+                typescript_1.default.createImportSpecifier(importPropertyName, importName)
         ]);
     }
     exports.replaceImport = replaceImport;
@@ -108,4 +114,4 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     }
     exports.findImportSpecifier = findImportSpecifier;
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"imports.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/utils/typescript/imports.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport ts from 'typescript';\n\nexport type Import = {\n  name: string,\n  importModule: string,\n  node: ts.ImportDeclaration\n};\n\n/** Gets import information about the specified identifier by using the Type checker. */\nexport function getImportOfIdentifier(typeChecker: ts.TypeChecker, node: ts.Identifier): Import|\n    null {\n  const symbol = typeChecker.getSymbolAtLocation(node);\n\n  if (!symbol || symbol.declarations === undefined || !symbol.declarations.length) {\n    return null;\n  }\n\n  const decl = symbol.declarations[0];\n\n  if (!ts.isImportSpecifier(decl)) {\n    return null;\n  }\n\n  const importDecl = decl.parent.parent.parent;\n\n  if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {\n    return null;\n  }\n\n  return {\n    // Handles aliased imports: e.g. \"import {Component as myComp} from ...\";\n    name: decl.propertyName ? decl.propertyName.text : decl.name.text,\n    importModule: importDecl.moduleSpecifier.text,\n    node: importDecl\n  };\n}\n\n\n/**\n * Gets a top-level import specifier with a specific name that is imported from a particular module.\n * E.g. given a file that looks like:\n *\n * ```\n * import { Component, Directive } from '@angular/core';\n * import { Foo } from './foo';\n * ```\n *\n * Calling `getImportSpecifier(sourceFile, '@angular/core', 'Directive')` will yield the node\n * referring to `Directive` in the top import.\n *\n * @param sourceFile File in which to look for imports.\n * @param moduleName Name of the import's module.\n * @param specifierName Original name of the specifier to look for. Aliases will be resolved to\n *    their original name.\n */\nexport function getImportSpecifier(\n    sourceFile: ts.SourceFile, moduleName: string, specifierName: string): ts.ImportSpecifier|null {\n  for (const node of sourceFile.statements) {\n    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) &&\n        node.moduleSpecifier.text === moduleName) {\n      const namedBindings = node.importClause && node.importClause.namedBindings;\n      if (namedBindings && ts.isNamedImports(namedBindings)) {\n        const match = findImportSpecifier(namedBindings.elements, specifierName);\n        if (match) {\n          return match;\n        }\n      }\n    }\n  }\n\n  return null;\n}\n\n\n/**\n * Replaces an import inside a named imports node with a different one.\n * @param node Node that contains the imports.\n * @param existingImport Import that should be replaced.\n * @param newImportName Import that should be inserted.\n */\nexport function replaceImport(\n    node: ts.NamedImports, existingImport: string, newImportName: string) {\n  const isAlreadyImported = findImportSpecifier(node.elements, newImportName);\n  if (isAlreadyImported) {\n    return node;\n  }\n\n  const existingImportNode = findImportSpecifier(node.elements, existingImport);\n  if (!existingImportNode) {\n    return node;\n  }\n\n  return ts.updateNamedImports(node, [\n    ...node.elements.filter(current => current !== existingImportNode),\n    // Create a new import while trying to preserve the alias of the old one.\n    ts.createImportSpecifier(\n        existingImportNode.propertyName ? ts.createIdentifier(newImportName) : undefined,\n        existingImportNode.propertyName ? existingImportNode.name :\n                                          ts.createIdentifier(newImportName))\n  ]);\n}\n\n\n/** Finds an import specifier with a particular name. */\nexport function findImportSpecifier(\n    nodes: ts.NodeArray<ts.ImportSpecifier>, specifierName: string): ts.ImportSpecifier|undefined {\n  return nodes.find(element => {\n    const {name, propertyName} = element;\n    return propertyName ? propertyName.text === specifierName : name.text === specifierName;\n  });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"imports.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/utils/typescript/imports.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport ts from 'typescript';\n\nexport type Import = {\n  name: string,\n  importModule: string,\n  node: ts.ImportDeclaration\n};\n\nconst PARSED_TS_VERSION = parseFloat(ts.versionMajorMinor);\n\n/** Gets import information about the specified identifier by using the Type checker. */\nexport function getImportOfIdentifier(typeChecker: ts.TypeChecker, node: ts.Identifier): Import|\n    null {\n  const symbol = typeChecker.getSymbolAtLocation(node);\n\n  if (!symbol || symbol.declarations === undefined || !symbol.declarations.length) {\n    return null;\n  }\n\n  const decl = symbol.declarations[0];\n\n  if (!ts.isImportSpecifier(decl)) {\n    return null;\n  }\n\n  const importDecl = decl.parent.parent.parent;\n\n  if (!ts.isStringLiteral(importDecl.moduleSpecifier)) {\n    return null;\n  }\n\n  return {\n    // Handles aliased imports: e.g. \"import {Component as myComp} from ...\";\n    name: decl.propertyName ? decl.propertyName.text : decl.name.text,\n    importModule: importDecl.moduleSpecifier.text,\n    node: importDecl\n  };\n}\n\n\n/**\n * Gets a top-level import specifier with a specific name that is imported from a particular module.\n * E.g. given a file that looks like:\n *\n * ```\n * import { Component, Directive } from '@angular/core';\n * import { Foo } from './foo';\n * ```\n *\n * Calling `getImportSpecifier(sourceFile, '@angular/core', 'Directive')` will yield the node\n * referring to `Directive` in the top import.\n *\n * @param sourceFile File in which to look for imports.\n * @param moduleName Name of the import's module.\n * @param specifierName Original name of the specifier to look for. Aliases will be resolved to\n *    their original name.\n */\nexport function getImportSpecifier(\n    sourceFile: ts.SourceFile, moduleName: string, specifierName: string): ts.ImportSpecifier|null {\n  for (const node of sourceFile.statements) {\n    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) &&\n        node.moduleSpecifier.text === moduleName) {\n      const namedBindings = node.importClause && node.importClause.namedBindings;\n      if (namedBindings && ts.isNamedImports(namedBindings)) {\n        const match = findImportSpecifier(namedBindings.elements, specifierName);\n        if (match) {\n          return match;\n        }\n      }\n    }\n  }\n\n  return null;\n}\n\n\n/**\n * Replaces an import inside a named imports node with a different one.\n * @param node Node that contains the imports.\n * @param existingImport Import that should be replaced.\n * @param newImportName Import that should be inserted.\n */\nexport function replaceImport(\n    node: ts.NamedImports, existingImport: string, newImportName: string) {\n  const isAlreadyImported = findImportSpecifier(node.elements, newImportName);\n  if (isAlreadyImported) {\n    return node;\n  }\n\n  const existingImportNode = findImportSpecifier(node.elements, existingImport);\n  if (!existingImportNode) {\n    return node;\n  }\n\n  const importPropertyName =\n      existingImportNode.propertyName ? ts.createIdentifier(newImportName) : undefined;\n  const importName = existingImportNode.propertyName ? existingImportNode.name :\n                                                       ts.createIdentifier(newImportName);\n\n  return ts.updateNamedImports(node, [\n    ...node.elements.filter(current => current !== existingImportNode),\n    // Create a new import while trying to preserve the alias of the old one.\n    PARSED_TS_VERSION > 4.4 ? ts.createImportSpecifier(false, importPropertyName, importName) :\n                              // TODO(crisbeto): backwards-compatibility layer for TS 4.4.\n                              // Should be cleaned up when we drop support for it.\n                              (ts.createImportSpecifier as any)(importPropertyName, importName)\n  ]);\n}\n\n\n/** Finds an import specifier with a particular name. */\nexport function findImportSpecifier(\n    nodes: ts.NodeArray<ts.ImportSpecifier>, specifierName: string): ts.ImportSpecifier|undefined {\n  return nodes.find(element => {\n    const {name, propertyName} = element;\n    return propertyName ? propertyName.text === specifierName : name.text === specifierName;\n  });\n}\n"]}

package/testing/testing.d.ts

@@ -1,22 +1,17 @@
 /**
- * @license Angular v13.1.0-next.2
- * (c) 2010-2021 Google LLC. https://angular.io/
+ * @license Angular v13.1.2
+ * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
 
 import { ChangeDetectorRef } from '@angular/core';
-import { Compiler } from '@angular/core';
-import { CompilerOptions } from '@angular/core';
 import { Component } from '@angular/core';
-import { ComponentFactory } from '@angular/core';
 import { ComponentRef } from '@angular/core';
 import { DebugElement } from '@angular/core';
 import { Directive } from '@angular/core';
 import { ElementRef } from '@angular/core';
-import * as i0 from '@angular/core';
 import { InjectFlags } from '@angular/core';
 import { InjectionToken } from '@angular/core';
-import { Injector } from '@angular/core';
 import { NgModule } from '@angular/core';
 import { NgZone } from '@angular/core';
 import { Pipe } from '@angular/core';
@@ -583,44 +578,4 @@ export declare class ɵMetadataOverrider {
     }, oldMetadata: C, override: MetadataOverride<T>): C;
 }
 
-/**
- * Special interface to the compiler only used by testing
- *
- * @publicApi
- */
-export declare class ɵTestingCompiler extends Compiler {
-    get injector(): Injector;
-    overrideModule(module: Type<any>, overrides: MetadataOverride<NgModule>): void;
-    overrideDirective(directive: Type<any>, overrides: MetadataOverride<Directive>): void;
-    overrideComponent(component: Type<any>, overrides: MetadataOverride<Component>): void;
-    overridePipe(directive: Type<any>, overrides: MetadataOverride<Pipe>): void;
-    /**
-     * Allows to pass the compile summary from AOT compilation to the JIT compiler,
-     * so that it can use the code generated by AOT.
-     */
-    loadAotSummaries(summaries: () => any[]): void;
-    /**
-     * Gets the component factory for the given component.
-     * This assumes that the component has been compiled before calling this call using
-     * `compileModuleAndAllComponents*`.
-     */
-    getComponentFactory<T>(component: Type<T>): ComponentFactory<T>;
-    /**
-     * Returns the component type that is stored in the given error.
-     * This can be used for errors created by compileModule...
-     */
-    getComponentFromError(error: Error): Type<any> | null;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ɵTestingCompiler, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ɵTestingCompiler>;
-}
-
-/**
- * A factory for creating a Compiler
- *
- * @publicApi
- */
-export declare abstract class ɵTestingCompilerFactory {
-    abstract createTestingCompiler(options?: CompilerOptions[]): ɵTestingCompiler;
-}
-
 export { }

package/esm2020/src/codegen_private_exports.mjs

@@ -1,11 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export { CodegenComponentFactoryResolver as ɵCodegenComponentFactoryResolver } from './linker/component_factory_resolver';
-export { registerModuleFactory as ɵregisterModuleFactory } from './linker/ng_module_factory_registration';
-export { anchorDef as ɵand, createComponentFactory as ɵccf, createNgModuleFactory as ɵcmf, createRendererType2 as ɵcrt, directiveDef as ɵdid, elementDef as ɵeld, EMPTY_ARRAY as ɵEMPTY_ARRAY, EMPTY_MAP as ɵEMPTY_MAP, getComponentViewDefinitionFactory as ɵgetComponentViewDefinitionFactory, inlineInterpolate as ɵinlineInterpolate, interpolate as ɵinterpolate, moduleDef as ɵmod, moduleProvideDef as ɵmpd, ngContentDef as ɵncd, nodeValue as ɵnov, pipeDef as ɵpid, providerDef as ɵprd, pureArrayDef as ɵpad, pureObjectDef as ɵpod, purePipeDef as ɵppd, queryDef as ɵqud, textDef as ɵted, viewDef as ɵvid } from './view/index';
-//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/debug/proxy.mjs

@@ -1,23 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { global } from '../util/global';
-/**
- * Creates an instance of a `Proxy` and creates with an empty target object and binds it to the
- * provided handler.
- *
- * The reason why this function exists is because IE doesn't support
- * the `Proxy` class. For this reason an error must be thrown.
- */
-export function createProxy(handler) {
-    const g = global;
-    if (!g.Proxy) {
-        throw new Error('Proxy is not supported in this browser');
-    }
-    return new g.Proxy({}, handler);
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJveHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9jb3JlL3NyYy9kZWJ1Zy9wcm94eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFDSCxPQUFPLEVBQUMsTUFBTSxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFTdEM7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLFdBQVcsQ0FBQyxPQUEwQjtJQUNwRCxNQUFNLENBQUMsR0FBRyxNQUFnQyxDQUFDO0lBQzNDLElBQUksQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFO1FBQ1osTUFBTSxJQUFJLEtBQUssQ0FBQyx3Q0FBd0MsQ0FBQyxDQUFDO0tBQzNEO0lBQ0QsT0FBTyxJQUFJLENBQUMsQ0FBQyxLQUFLLENBQUMsRUFBRSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0FBQ2xDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cbmltcG9ydCB7Z2xvYmFsfSBmcm9tICcuLi91dGlsL2dsb2JhbCc7XG5cbi8qKlxuICogVXNlZCB0byBpbmZvcm0gVFMgYWJvdXQgdGhlIGBQcm94eWAgY2xhc3MgZXhpc3RpbmcgZ2xvYmFsbHkuXG4gKi9cbmludGVyZmFjZSBHbG9iYWxXaXRoUHJveHkge1xuICBQcm94eTogdHlwZW9mIFByb3h5O1xufVxuXG4vKipcbiAqIENyZWF0ZXMgYW4gaW5zdGFuY2Ugb2YgYSBgUHJveHlgIGFuZCBjcmVhdGVzIHdpdGggYW4gZW1wdHkgdGFyZ2V0IG9iamVjdCBhbmQgYmluZHMgaXQgdG8gdGhlXG4gKiBwcm92aWRlZCBoYW5kbGVyLlxuICpcbiAqIFRoZSByZWFzb24gd2h5IHRoaXMgZnVuY3Rpb24gZXhpc3RzIGlzIGJlY2F1c2UgSUUgZG9lc24ndCBzdXBwb3J0XG4gKiB0aGUgYFByb3h5YCBjbGFzcy4gRm9yIHRoaXMgcmVhc29uIGFuIGVycm9yIG11c3QgYmUgdGhyb3duLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlUHJveHkoaGFuZGxlcjogUHJveHlIYW5kbGVyPGFueT4pOiB7fSB7XG4gIGNvbnN0IGcgPSBnbG9iYWwgYXMgYW55IGFzIEdsb2JhbFdpdGhQcm94eTtcbiAgaWYgKCFnLlByb3h5KSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKCdQcm94eSBpcyBub3Qgc3VwcG9ydGVkIGluIHRoaXMgYnJvd3NlcicpO1xuICB9XG4gIHJldHVybiBuZXcgZy5Qcm94eSh7fSwgaGFuZGxlcik7XG59XG4iXX0=

package/esm2020/src/ivy_switch.mjs

@@ -1,11 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export const SWITCH_IVY_ENABLED__POST_R3__ = true;
-const SWITCH_IVY_ENABLED__PRE_R3__ = false;
-export const ivyEnabled = SWITCH_IVY_ENABLED__POST_R3__;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXZ5X3N3aXRjaC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL2l2eV9zd2l0Y2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQUcsSUFBSSxDQUFDO0FBQ2xELE1BQU0sNEJBQTRCLEdBQUcsS0FBSyxDQUFDO0FBQzNDLE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FGViw2QkFFeUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgY29uc3QgU1dJVENIX0lWWV9FTkFCTEVEX19QT1NUX1IzX18gPSB0cnVlO1xuY29uc3QgU1dJVENIX0lWWV9FTkFCTEVEX19QUkVfUjNfXyA9IGZhbHNlO1xuZXhwb3J0IGNvbnN0IGl2eUVuYWJsZWQgPSBTV0lUQ0hfSVZZX0VOQUJMRURfX1BSRV9SM19fO1xuIl19

package/esm2020/src/render3/error_code.mjs

@@ -1,42 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { ERROR_DETAILS_PAGE_BASE_URL } from './error_details_base_url';
-export class RuntimeError extends Error {
-    constructor(code, message) {
-        super(formatRuntimeError(code, message));
-        this.code = code;
-    }
-}
-// Contains a set of error messages that have details guides at angular.io.
-// Full list of available error guides can be found at https://angular.io/errors
-/* tslint:disable:no-toplevel-property-access */
-export const RUNTIME_ERRORS_WITH_GUIDES = new Set([
-    "100" /* EXPRESSION_CHANGED_AFTER_CHECKED */,
-    "200" /* CYCLIC_DI_DEPENDENCY */,
-    "201" /* PROVIDER_NOT_FOUND */,
-    "300" /* MULTIPLE_COMPONENTS_MATCH */,
-    "301" /* EXPORT_NOT_FOUND */,
-    "302" /* PIPE_NOT_FOUND */,
-]);
-/* tslint:enable:no-toplevel-property-access */
-/** Called to format a runtime error */
-export function formatRuntimeError(code, message) {
-    const fullCode = code ? `NG0${code}: ` : '';
-    let errorMessage = `${fullCode}${message}`;
-    // Some runtime errors are still thrown without `ngDevMode` (for example
-    // `throwProviderNotFoundError`), so we add `ngDevMode` check here to avoid pulling
-    // `RUNTIME_ERRORS_WITH_GUIDES` symbol into prod bundles.
-    // TODO: revisit all instances where `RuntimeError` is thrown and see if `ngDevMode` can be added
-    // there instead to tree-shake more devmode-only code (and eventually remove `ngDevMode` check
-    // from this code).
-    if (ngDevMode && RUNTIME_ERRORS_WITH_GUIDES.has(code)) {
-        errorMessage = `${errorMessage}. Find more at ${ERROR_DETAILS_PAGE_BASE_URL}/NG0${code}`;
-    }
-    return errorMessage;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JfY29kZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2NvcmUvc3JjL3JlbmRlcjMvZXJyb3JfY29kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsMkJBQTJCLEVBQUMsTUFBTSwwQkFBMEIsQ0FBQztBQTZCckUsTUFBTSxPQUFPLFlBQWEsU0FBUSxLQUFLO0lBQ3JDLFlBQW1CLElBQXNCLEVBQUUsT0FBZTtRQUN4RCxLQUFLLENBQUMsa0JBQWtCLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUM7UUFEeEIsU0FBSSxHQUFKLElBQUksQ0FBa0I7SUFFekMsQ0FBQztDQUNGO0FBRUQsMkVBQTJFO0FBQzNFLGdGQUFnRjtBQUNoRixnREFBZ0Q7QUFDaEQsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQUcsSUFBSSxHQUFHLENBQUM7Ozs7Ozs7Q0FPakQsQ0FBQyxDQUFDO0FBQ0gsK0NBQStDO0FBRS9DLHVDQUF1QztBQUN2QyxNQUFNLFVBQVUsa0JBQWtCLENBQUMsSUFBc0IsRUFBRSxPQUFlO0lBQ3hFLE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO0lBRTVDLElBQUksWUFBWSxHQUFHLEdBQUcsUUFBUSxHQUFHLE9BQU8sRUFBRSxDQUFDO0lBRTNDLHdFQUF3RTtJQUN4RSxtRkFBbUY7SUFDbkYseURBQXlEO0lBQ3pELGlHQUFpRztJQUNqRyw4RkFBOEY7SUFDOUYsbUJBQW1CO0lBQ25CLElBQUksU0FBUyxJQUFJLDBCQUEwQixDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsRUFBRTtRQUNyRCxZQUFZLEdBQUcsR0FBRyxZQUFZLGtCQUFrQiwyQkFBMkIsT0FBTyxJQUFJLEVBQUUsQ0FBQztLQUMxRjtJQUNELE9BQU8sWUFBWSxDQUFDO0FBQ3RCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtFUlJPUl9ERVRBSUxTX1BBR0VfQkFTRV9VUkx9IGZyb20gJy4vZXJyb3JfZGV0YWlsc19iYXNlX3VybCc7XG5cbmV4cG9ydCBjb25zdCBlbnVtIFJ1bnRpbWVFcnJvckNvZGUge1xuICAvLyBJbnRlcm5hbCBFcnJvcnNcblxuICAvLyBDaGFuZ2UgRGV0ZWN0aW9uIEVycm9yc1xuICBFWFBSRVNTSU9OX0NIQU5HRURfQUZURVJfQ0hFQ0tFRCA9ICcxMDAnLFxuXG4gIC8vIERlcGVuZGVuY3kgSW5qZWN0aW9uIEVycm9yc1xuICBDWUNMSUNfRElfREVQRU5ERU5DWSA9ICcyMDAnLFxuICBQUk9WSURFUl9OT1RfRk9VTkQgPSAnMjAxJyxcblxuICAvLyBUZW1wbGF0ZSBFcnJvcnNcbiAgTVVMVElQTEVfQ09NUE9ORU5UU19NQVRDSCA9ICczMDAnLFxuICBFWFBPUlRfTk9UX0ZPVU5EID0gJzMwMScsXG4gIFBJUEVfTk9UX0ZPVU5EID0gJzMwMicsXG4gIFVOS05PV05fQklORElORyA9ICczMDMnLFxuICBVTktOT1dOX0VMRU1FTlQgPSAnMzA0JyxcbiAgVEVNUExBVEVfU1RSVUNUVVJFX0VSUk9SID0gJzMwNSdcblxuICAvLyBTdHlsaW5nIEVycm9yc1xuXG4gIC8vIERlY2xhcmF0aW9ucyBFcnJvcnNcblxuICAvLyBpMThuIEVycm9yc1xuXG4gIC8vIENvbXBpbGF0aW9uIEVycm9yc1xufVxuXG5leHBvcnQgY2xhc3MgUnVudGltZUVycm9yIGV4dGVuZHMgRXJyb3Ige1xuICBjb25zdHJ1Y3RvcihwdWJsaWMgY29kZTogUnVudGltZUVycm9yQ29kZSwgbWVzc2FnZTogc3RyaW5nKSB7XG4gICAgc3VwZXIoZm9ybWF0UnVudGltZUVycm9yKGNvZGUsIG1lc3NhZ2UpKTtcbiAgfVxufVxuXG4vLyBDb250YWlucyBhIHNldCBvZiBlcnJvciBtZXNzYWdlcyB0aGF0IGhhdmUgZGV0YWlscyBndWlkZXMgYXQgYW5ndWxhci5pby5cbi8vIEZ1bGwgbGlzdCBvZiBhdmFpbGFibGUgZXJyb3IgZ3VpZGVzIGNhbiBiZSBmb3VuZCBhdCBodHRwczovL2FuZ3VsYXIuaW8vZXJyb3JzXG4vKiB0c2xpbnQ6ZGlzYWJsZTpuby10b3BsZXZlbC1wcm9wZXJ0eS1hY2Nlc3MgKi9cbmV4cG9ydCBjb25zdCBSVU5USU1FX0VSUk9SU19XSVRIX0dVSURFUyA9IG5ldyBTZXQoW1xuICBSdW50aW1lRXJyb3JDb2RlLkVYUFJFU1NJT05fQ0hBTkdFRF9BRlRFUl9DSEVDS0VELFxuICBSdW50aW1lRXJyb3JDb2RlLkNZQ0xJQ19ESV9ERVBFTkRFTkNZLFxuICBSdW50aW1lRXJyb3JDb2RlLlBST1ZJREVSX05PVF9GT1VORCxcbiAgUnVudGltZUVycm9yQ29kZS5NVUxUSVBMRV9DT01QT05FTlRTX01BVENILFxuICBSdW50aW1lRXJyb3JDb2RlLkVYUE9SVF9OT1RfRk9VTkQsXG4gIFJ1bnRpbWVFcnJvckNvZGUuUElQRV9OT1RfRk9VTkQsXG5dKTtcbi8qIHRzbGludDplbmFibGU6bm8tdG9wbGV2ZWwtcHJvcGVydHktYWNjZXNzICovXG5cbi8qKiBDYWxsZWQgdG8gZm9ybWF0IGEgcnVudGltZSBlcnJvciAqL1xuZXhwb3J0IGZ1bmN0aW9uIGZvcm1hdFJ1bnRpbWVFcnJvcihjb2RlOiBSdW50aW1lRXJyb3JDb2RlLCBtZXNzYWdlOiBzdHJpbmcpOiBzdHJpbmcge1xuICBjb25zdCBmdWxsQ29kZSA9IGNvZGUgPyBgTkcwJHtjb2RlfTogYCA6ICcnO1xuXG4gIGxldCBlcnJvck1lc3NhZ2UgPSBgJHtmdWxsQ29kZX0ke21lc3NhZ2V9YDtcblxuICAvLyBTb21lIHJ1bnRpbWUgZXJyb3JzIGFyZSBzdGlsbCB0aHJvd24gd2l0aG91dCBgbmdEZXZNb2RlYCAoZm9yIGV4YW1wbGVcbiAgLy8gYHRocm93UHJvdmlkZXJOb3RGb3VuZEVycm9yYCksIHNvIHdlIGFkZCBgbmdEZXZNb2RlYCBjaGVjayBoZXJlIHRvIGF2b2lkIHB1bGxpbmdcbiAgLy8gYFJVTlRJTUVfRVJST1JTX1dJVEhfR1VJREVTYCBzeW1ib2wgaW50byBwcm9kIGJ1bmRsZXMuXG4gIC8vIFRPRE86IHJldmlzaXQgYWxsIGluc3RhbmNlcyB3aGVyZSBgUnVudGltZUVycm9yYCBpcyB0aHJvd24gYW5kIHNlZSBpZiBgbmdEZXZNb2RlYCBjYW4gYmUgYWRkZWRcbiAgLy8gdGhlcmUgaW5zdGVhZCB0byB0cmVlLXNoYWtlIG1vcmUgZGV2bW9kZS1vbmx5IGNvZGUgKGFuZCBldmVudHVhbGx5IHJlbW92ZSBgbmdEZXZNb2RlYCBjaGVja1xuICAvLyBmcm9tIHRoaXMgY29kZSkuXG4gIGlmIChuZ0Rldk1vZGUgJiYgUlVOVElNRV9FUlJPUlNfV0lUSF9HVUlERVMuaGFzKGNvZGUpKSB7XG4gICAgZXJyb3JNZXNzYWdlID0gYCR7ZXJyb3JNZXNzYWdlfS4gRmluZCBtb3JlIGF0ICR7RVJST1JfREVUQUlMU19QQUdFX0JBU0VfVVJMfS9ORzAke2NvZGV9YDtcbiAgfVxuICByZXR1cm4gZXJyb3JNZXNzYWdlO1xufVxuIl19