@angular/core 20.0.0-next.3 → 20.0.0-next.5

package/schematics/bundles/compiler_host-CAfDJO3W.js

@@ -0,0 +1,129 @@
+'use strict';
+/**
+ * @license Angular v20.0.0-next.5
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+var p = require('path');
+var ts = require('typescript');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var p__namespace = /*#__PURE__*/_interopNamespaceDefault(p);
+
+function parseTsconfigFile(tsconfigPath, basePath) {
+    const { config } = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    const parseConfigHost = {
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+        fileExists: ts.sys.fileExists,
+        readDirectory: ts.sys.readDirectory,
+        readFile: ts.sys.readFile,
+    };
+    // Throw if incorrect arguments are passed to this function. Passing relative base paths
+    // results in root directories not being resolved and in later type checking runtime errors.
+    // More details can be found here: https://github.com/microsoft/TypeScript/issues/37731.
+    if (!p__namespace.isAbsolute(basePath)) {
+        throw Error('Unexpected relative base path has been specified.');
+    }
+    return ts.parseJsonConfigFileContent(config, parseConfigHost, basePath, {});
+}
+
+/**
+ * Creates a TypeScript program instance for a TypeScript project within
+ * the virtual file system tree.
+ * @param tree Virtual file system tree that contains the source files.
+ * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
+ * @param basePath Base path for the virtual file system tree.
+ * @param fakeFileRead Optional file reader function. Can be used to overwrite files in
+ *   the TypeScript program, or to add in-memory files (e.g. to add global types).
+ * @param additionalFiles Additional file paths that should be added to the program.
+ */
+function createMigrationProgram(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles) {
+    const { rootNames, options, host } = createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead);
+    return ts.createProgram(rootNames, options, host);
+}
+/**
+ * Creates the options necessary to instantiate a TypeScript program.
+ * @param tree Virtual file system tree that contains the source files.
+ * @param tsconfigPath Virtual file system path that resolves to the TypeScript project.
+ * @param basePath Base path for the virtual file system tree.
+ * @param fakeFileRead Optional file reader function. Can be used to overwrite files in
+ *   the TypeScript program, or to add in-memory files (e.g. to add global types).
+ * @param additionalFiles Additional file paths that should be added to the program.
+ * @param optionOverrides Overrides of the parsed compiler options.
+ */
+function createProgramOptions(tree, tsconfigPath, basePath, fakeFileRead, additionalFiles, optionOverrides) {
+    // Resolve the tsconfig path to an absolute path. This is needed as TypeScript otherwise
+    // is not able to resolve root directories in the given tsconfig. More details can be found
+    // in the following issue: https://github.com/microsoft/TypeScript/issues/37731.
+    tsconfigPath = p.resolve(basePath, tsconfigPath);
+    const parsed = parseTsconfigFile(tsconfigPath, p.dirname(tsconfigPath));
+    const options = optionOverrides ? { ...parsed.options, ...optionOverrides } : parsed.options;
+    const host = createMigrationCompilerHost(tree, options, basePath, fakeFileRead);
+    return { rootNames: parsed.fileNames.concat([]), options, host };
+}
+function createMigrationCompilerHost(tree, options, basePath, fakeRead) {
+    const host = ts.createCompilerHost(options, true);
+    const defaultReadFile = host.readFile;
+    // We need to overwrite the host "readFile" method, as we want the TypeScript
+    // program to be based on the file contents in the virtual file tree. Otherwise
+    // if we run multiple migrations we might have intersecting changes and
+    // source files.
+    host.readFile = (fileName) => {
+        const treeRelativePath = p.relative(basePath, fileName);
+        let result = fakeRead?.(treeRelativePath);
+        if (typeof result !== 'string') {
+            // If the relative path resolved to somewhere outside of the tree, fall back to
+            // TypeScript's default file reading function since the `tree` will throw an error.
+            result = treeRelativePath.startsWith('..')
+                ? defaultReadFile.call(host, fileName)
+                : tree.read(treeRelativePath)?.toString();
+        }
+        // Strip BOM as otherwise TSC methods (Ex: getWidth) will return an offset,
+        // which breaks the CLI UpdateRecorder.
+        // See: https://github.com/angular/angular/pull/30719
+        return typeof result === 'string' ? result.replace(/^\uFEFF/, '') : undefined;
+    };
+    return host;
+}
+/**
+ * Checks whether a file can be migrate by our automated migrations.
+ * @param basePath Absolute path to the project.
+ * @param sourceFile File being checked.
+ * @param program Program that includes the source file.
+ */
+function canMigrateFile(basePath, sourceFile, program) {
+    // We shouldn't migrate .d.ts files, files from an external library or type checking files.
+    if (sourceFile.fileName.endsWith('.ngtypecheck.ts') ||
+        sourceFile.isDeclarationFile ||
+        program.isSourceFileFromExternalLibrary(sourceFile)) {
+        return false;
+    }
+    // Our migrations are set up to create a `Program` from the project's tsconfig and to migrate all
+    // the files within the program. This can include files that are outside of the Angular CLI
+    // project. We can't migrate files outside of the project, because our file system interactions
+    // go through the CLI's `Tree` which assumes that all files are within the project. See:
+    // https://github.com/angular/angular-cli/blob/0b0961c9c233a825b6e4bb59ab7f0790f9b14676/packages/angular_devkit/schematics/src/tree/host-tree.ts#L131
+    return !p.relative(basePath, sourceFile.fileName).startsWith('..');
+}
+
+exports.canMigrateFile = canMigrateFile;
+exports.createMigrationProgram = createMigrationProgram;
+exports.createProgramOptions = createProgramOptions;

package/schematics/bundles/control-flow-migration.js

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.3
+ * @license Angular v20.0.0-next.5
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -8,13 +8,11 @@
 
 var schematics = require('@angular-devkit/schematics');
 var p = require('path');
-var compiler_host = require('./compiler_host-Bk3repE2.js');
-var checker = require('./checker-BHb19MHt.js');
+var compiler_host = require('./compiler_host-CAfDJO3W.js');
+var compiler = require('./compiler-CuoiHqkc.js');
 var ts = require('typescript');
-require('os');
-require('fs');
-require('module');
-require('url');
+var project_tsconfig_paths = require('./project_tsconfig_paths-CDVxT6Ov.js');
+require('@angular-devkit/core');
 
 function lookupIdentifiersInSourceFile(sourceFile, names) {
     const results = new Set();
@@ -273,7 +271,7 @@ class AnalyzedFile {
     }
 }
 /** Finds all non-control flow elements from common module. */
-class CommonCollector extends checker.RecursiveVisitor {
+class CommonCollector extends compiler.RecursiveVisitor$1 {
     count = 0;
     visitElement(el) {
         if (el.attrs.length > 0) {
@@ -312,7 +310,7 @@ class CommonCollector extends checker.RecursiveVisitor {
     }
 }
 /** Finds all elements that represent i18n blocks. */
-class i18nCollector extends checker.RecursiveVisitor {
+class i18nCollector extends compiler.RecursiveVisitor$1 {
     elements = [];
     visitElement(el) {
         if (el.attrs.find((a) => a.name === 'i18n') !== undefined) {
@@ -322,7 +320,7 @@ class i18nCollector extends checker.RecursiveVisitor {
     }
 }
 /** Finds all elements with ngif structural directives. */
-class ElementCollector extends checker.RecursiveVisitor {
+class ElementCollector extends compiler.RecursiveVisitor$1 {
     _attributes;
     elements = [];
     constructor(_attributes = []) {
@@ -375,7 +373,7 @@ class ElementCollector extends checker.RecursiveVisitor {
     }
 }
 /** Finds all elements with ngif structural directives. */
-class TemplateCollector extends checker.RecursiveVisitor {
+class TemplateCollector extends compiler.RecursiveVisitor$1 {
     elements = [];
     templates = new Map();
     visitElement(el) {
@@ -589,7 +587,7 @@ function parseTemplate(template) {
         // interpolated text as text nodes containing a mixture of interpolation tokens and text tokens,
         // rather than turning them into `BoundText` nodes like the Ivy AST does. This allows us to
         // easily get the text-only ranges without having to reconstruct the original text.
-        parsed = new checker.HtmlParser().parse(template, '', {
+        parsed = new compiler.HtmlParser().parse(template, '', {
             // Allows for ICUs to be parsed.
             tokenizeExpansionForms: true,
             // Explicitly disable blocks so that their characters are treated as plain text.
@@ -627,7 +625,7 @@ function validateMigratedTemplate(migrated, fileName) {
 }
 function validateI18nStructure(parsed, fileName) {
     const visitor = new i18nCollector();
-    checker.visitAll(visitor, parsed.rootNodes);
+    compiler.visitAll$1(visitor, parsed.rootNodes);
     const parents = visitor.elements.filter((el) => el.children.length > 0);
     for (const p of parents) {
         for (const el of visitor.elements) {
@@ -680,9 +678,6 @@ function calculateNesting(visitor, hasLineBreaks) {
         }
     }
 }
-function escapeRegExp(val) {
-    return val.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
-}
 /**
  * determines if a given template string contains line breaks
  */
@@ -710,19 +705,43 @@ function getTemplates(template) {
     const parsed = parseTemplate(template);
     if (parsed.tree !== undefined) {
         const visitor = new TemplateCollector();
-        checker.visitAll(visitor, parsed.tree.rootNodes);
-        // count usages of each ng-template
+        compiler.visitAll$1(visitor, parsed.tree.rootNodes);
         for (let [key, tmpl] of visitor.templates) {
-            const escapeKey = escapeRegExp(key.slice(1));
-            const regex = new RegExp(`[^a-zA-Z0-9-<(\']${escapeKey}\\W`, 'gm');
-            const matches = template.match(regex);
-            tmpl.count = matches?.length ?? 0;
+            tmpl.count = countTemplateUsage(parsed.tree.rootNodes, key);
             tmpl.generateContents(template);
         }
         return visitor.templates;
     }
     return new Map();
 }
+function countTemplateUsage(nodes, templateName) {
+    let count = 0;
+    let isReferencedInTemplateOutlet = false;
+    for (const node of nodes) {
+        if (node.attrs) {
+            for (const attr of node.attrs) {
+                if (attr.name === '*ngTemplateOutlet' && attr.value === templateName.slice(1)) {
+                    isReferencedInTemplateOutlet = true;
+                    break;
+                }
+                if (attr.name.trim() === templateName) {
+                    count++;
+                }
+            }
+        }
+        if (node.children) {
+            if (node.name === 'for') {
+                for (const child of node.children) {
+                    if (child.value?.includes(templateName.slice(1))) {
+                        count++;
+                    }
+                }
+            }
+            count += countTemplateUsage(node.children, templateName);
+        }
+    }
+    return isReferencedInTemplateOutlet ? count + 2 : count;
+}
 function updateTemplates(template, templates) {
     const updatedTemplates = getTemplates(template);
     for (let [key, tmpl] of updatedTemplates) {
@@ -772,8 +791,8 @@ function processNgTemplates(template, sourceFile) {
                 else {
                     template = template.replace(replaceRegex, t.children);
                 }
-                // the +1 accounts for the t.count's counting of the original template
-                if (t.count === matches.length + 1 && safeToRemove) {
+                const dist = matches.filter((obj, index, self) => index === self.findIndex((t) => t.input === obj.input));
+                if ((t.count === dist.length || t.count - matches.length === 1) && safeToRemove) {
                     const refsInComponentFile = getViewChildOrViewChildrenNames(sourceFile);
                     if (refsInComponentFile?.length > 0) {
                         const templateRefs = getTemplateReferences(template);
@@ -862,7 +881,7 @@ function canRemoveCommonModule(template) {
     let removeCommonModule = false;
     if (parsed.tree !== undefined) {
         const visitor = new CommonCollector();
-        checker.visitAll(visitor, parsed.tree.rootNodes);
+        compiler.visitAll$1(visitor, parsed.tree.rootNodes);
         removeCommonModule = visitor.count === 0;
     }
     return removeCommonModule;
@@ -985,7 +1004,7 @@ function generateI18nMarkers(tmpl) {
     let parsed = parseTemplate(tmpl);
     if (parsed.tree !== undefined) {
         const visitor = new i18nCollector();
-        checker.visitAll(visitor, parsed.tree.rootNodes);
+        compiler.visitAll$1(visitor, parsed.tree.rootNodes);
         for (const [ix, el] of visitor.elements.entries()) {
             // we only care about elements with children and i18n tags
             // elements without children have nothing to translate
@@ -1187,7 +1206,7 @@ function migrateCase(template) {
     }
     let result = template;
     const visitor = new ElementCollector(cases);
-    checker.visitAll(visitor, parsed.tree.rootNodes);
+    compiler.visitAll$1(visitor, parsed.tree.rootNodes);
     calculateNesting(visitor, hasLineBreaks(template));
     // this tracks the character shift from different lengths of blocks from
     // the prior directives so as to adjust for nested block replacement during
@@ -1284,7 +1303,7 @@ function migrateFor(template) {
     }
     let result = template;
     const visitor = new ElementCollector(fors);
-    checker.visitAll(visitor, parsed.tree.rootNodes);
+    compiler.visitAll$1(visitor, parsed.tree.rootNodes);
     calculateNesting(visitor, hasLineBreaks(template));
     // this tracks the character shift from different lengths of blocks from
     // the prior directives so as to adjust for nested block replacement during
@@ -1489,7 +1508,7 @@ function migrateIf(template) {
     }
     let result = template;
     const visitor = new ElementCollector(ifs);
-    checker.visitAll(visitor, parsed.tree.rootNodes);
+    compiler.visitAll$1(visitor, parsed.tree.rootNodes);
     calculateNesting(visitor, hasLineBreaks(template));
     // this tracks the character shift from different lengths of blocks from
     // the prior directives so as to adjust for nested block replacement during
@@ -1682,7 +1701,7 @@ function migrateSwitch(template) {
     }
     let result = template;
     const visitor = new ElementCollector(switches);
-    checker.visitAll(visitor, parsed.tree.rootNodes);
+    compiler.visitAll$1(visitor, parsed.tree.rootNodes);
     calculateNesting(visitor, hasLineBreaks(template));
     // this tracks the character shift from different lengths of blocks from
     // the prior directives so as to adjust for nested block replacement during
@@ -1713,11 +1732,11 @@ function migrateSwitch(template) {
 }
 function assertValidSwitchStructure(children) {
     for (const child of children) {
-        if (child instanceof checker.Text && child.value.trim() !== '') {
+        if (child instanceof compiler.Text && child.value.trim() !== '') {
             throw new Error(`Text node: "${child.value}" would result in invalid migrated @switch block structure. ` +
                 `@switch can only have @case or @default as children.`);
         }
-        else if (child instanceof checker.Element) {
+        else if (child instanceof compiler.Element$1) {
             let hasCase = false;
             for (const attr of child.attrs) {
                 if (cases.includes(attr.name)) {
@@ -1815,20 +1834,17 @@ function migrateTemplate(template, templateType, node, file, format = true, anal
     return { migrated, errors };
 }
 
-function migrate(options) {
+function migrate() {
     return async (tree, context) => {
+        const { buildPaths, testPaths } = await project_tsconfig_paths.getProjectTsConfigPaths(tree);
         const basePath = process.cwd();
-        const pathToMigrate = compiler_host.normalizePath(p.join(basePath, options.path));
-        let allPaths = [];
-        if (pathToMigrate.trim() !== '') {
-            allPaths.push(pathToMigrate);
-        }
+        const allPaths = [...buildPaths, ...testPaths];
         if (!allPaths.length) {
-            throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run the control flow migration.');
+            throw new schematics.SchematicsException('Could not find any tsconfig file. Cannot run the http providers migration.');
         }
         let errors = [];
         for (const tsconfigPath of allPaths) {
-            const migrateErrors = runControlFlowMigration(tree, tsconfigPath, basePath, pathToMigrate, options);
+            const migrateErrors = runControlFlowMigration(tree, tsconfigPath, basePath);
             errors = [...errors, ...migrateErrors];
         }
         if (errors.length > 0) {
@@ -1839,18 +1855,11 @@ function migrate(options) {
         }
     };
 }
-function runControlFlowMigration(tree, tsconfigPath, basePath, pathToMigrate, schematicOptions) {
-    if (schematicOptions.path.startsWith('..')) {
-        throw new schematics.SchematicsException('Cannot run control flow migration outside of the current project.');
-    }
+function runControlFlowMigration(tree, tsconfigPath, basePath) {
     const program = compiler_host.createMigrationProgram(tree, tsconfigPath, basePath);
     const sourceFiles = program
         .getSourceFiles()
-        .filter((sourceFile) => sourceFile.fileName.startsWith(pathToMigrate) &&
-        compiler_host.canMigrateFile(basePath, sourceFile, program));
-    if (sourceFiles.length === 0) {
-        throw new schematics.SchematicsException(`Could not find any files to migrate under the path ${pathToMigrate}. Cannot run the control flow migration.`);
-    }
+        .filter((sourceFile) => compiler_host.canMigrateFile(basePath, sourceFile, program));
     const analysis = new Map();
     const migrateErrors = new Map();
     for (const sourceFile of sourceFiles) {
@@ -1868,7 +1877,7 @@ function runControlFlowMigration(tree, tsconfigPath, basePath, pathToMigrate, sc
         for (const { start, end, node, type } of ranges) {
             const template = content.slice(start, end);
             const length = (end ?? content.length) - start;
-            const { migrated, errors } = migrateTemplate(template, type, node, file, schematicOptions.format, analysis);
+            const { migrated, errors } = migrateTemplate(template, type, node, file, true, analysis);
             if (migrated !== null) {
                 update.remove(start, length);
                 update.insertLeft(start, migrated);

package/schematics/bundles/document-core.js

@@ -0,0 +1,96 @@
+'use strict';
+/**
+ * @license Angular v20.0.0-next.5
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+'use strict';
+
+require('./compiler-CuoiHqkc.js');
+require('typescript');
+var checker = require('./checker-DqUKCGda.js');
+require('os');
+var apply_import_manager = require('./apply_import_manager-C-ysxahq.js');
+require('./index-WFXCe5Q0.js');
+require('path');
+var run_in_devkit = require('./run_in_devkit-CmHxABFr.js');
+var imports = require('./imports-CIX-JgAN.js');
+require('@angular-devkit/core');
+require('node:path/posix');
+require('fs');
+require('module');
+require('url');
+require('@angular-devkit/schematics');
+require('./project_tsconfig_paths-CDVxT6Ov.js');
+
+/** Migration that moves the import of `DOCUMENT` from `core` to `common`. */
+class DocumentCoreMigration extends run_in_devkit.TsurgeFunnelMigration {
+    async analyze(info) {
+        const replacements = [];
+        let importManager = null;
+        for (const sourceFile of info.sourceFiles) {
+            const specifier = imports.getImportSpecifier(sourceFile, '@angular/common', 'DOCUMENT');
+            if (specifier === null) {
+                continue;
+            }
+            importManager ??= new checker.ImportManager({
+                // Prevent the manager from trying to generate a non-conflicting import.
+                generateUniqueIdentifier: () => null,
+                shouldUseSingleQuotes: () => true,
+            });
+            importManager.removeImport(sourceFile, 'DOCUMENT', '@angular/common');
+            importManager.addImport({
+                exportSymbolName: 'DOCUMENT',
+                exportModuleSpecifier: '@angular/core',
+                requestedFile: sourceFile,
+                unsafeAliasOverride: specifier.propertyName ? specifier.name.text : undefined,
+            });
+        }
+        if (importManager !== null) {
+            apply_import_manager.applyImportManagerChanges(importManager, replacements, info.sourceFiles, info);
+        }
+        return run_in_devkit.confirmAsSerializable({ replacements });
+    }
+    async migrate(globalData) {
+        return run_in_devkit.confirmAsSerializable(globalData);
+    }
+    async combine(unitA, unitB) {
+        const seen = new Set();
+        const combined = [];
+        [unitA.replacements, unitB.replacements].forEach((replacements) => {
+            replacements.forEach((current) => {
+                const { position, end, toInsert } = current.update.data;
+                const key = current.projectFile.id + '/' + position + '/' + end + '/' + toInsert;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    combined.push(current);
+                }
+            });
+        });
+        return run_in_devkit.confirmAsSerializable({ replacements: combined });
+    }
+    async globalMeta(combinedData) {
+        return run_in_devkit.confirmAsSerializable(combinedData);
+    }
+    async stats() {
+        return { counters: {} };
+    }
+}
+
+/*!
+ * @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.dev/license
+ */
+function migrate() {
+    return async (tree) => {
+        await run_in_devkit.runMigrationInDevkit({
+            tree,
+            getMigration: () => new DocumentCoreMigration(),
+        });
+    };
+}
+
+exports.migrate = migrate;

package/schematics/bundles/imports-CIX-JgAN.js

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.3
+ * @license Angular v20.0.0-next.5
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */

package/schematics/bundles/{index-BL9kAIe5.js → index-CwFQSYXZ.js}

@@ -1,6 +1,6 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.3
+ * @license Angular v20.0.0-next.5
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -8,10 +8,11 @@
 
 var ts = require('typescript');
 require('os');
-var checker = require('./checker-BHb19MHt.js');
-var index = require('./index-I8VbxQcO.js');
+var checker = require('./checker-DqUKCGda.js');
+var compiler = require('./compiler-CuoiHqkc.js');
+var index = require('./index-WFXCe5Q0.js');
 require('path');
-var run_in_devkit = require('./run_in_devkit-C0JPtK2u.js');
+var run_in_devkit = require('./run_in_devkit-CmHxABFr.js');
 
 function getMemberName(member) {
     if (member.name === undefined) {
@@ -188,7 +189,7 @@ function lookupPropertyAccess(checker, type, path, options = {}) {
  * This resolution is important to be able to migrate references to inputs
  * that will be migrated to signal inputs.
  */
-class TemplateReferenceVisitor extends checker.RecursiveVisitor$1 {
+class TemplateReferenceVisitor extends compiler.RecursiveVisitor {
     result = [];
     /**
      * Whether we are currently descending into HTML AST nodes
@@ -235,21 +236,21 @@ class TemplateReferenceVisitor extends checker.RecursiveVisitor$1 {
         // of signal calls in templates.
         // TODO: Remove with: https://github.com/angular/angular/pull/55456.
         this.templateAttributeReferencedFields = [];
-        checker.visitAll$1(this, template.attributes);
-        checker.visitAll$1(this, template.templateAttrs);
+        compiler.visitAll(this, template.attributes);
+        compiler.visitAll(this, template.templateAttrs);
         // If we are dealing with a microsyntax template, do not check
         // inputs and outputs as those are already passed to the children.
         // Template attributes may contain relevant expressions though.
         if (template.tagName === 'ng-template') {
-            checker.visitAll$1(this, template.inputs);
-            checker.visitAll$1(this, template.outputs);
+            compiler.visitAll(this, template.inputs);
+            compiler.visitAll(this, template.outputs);
         }
         const referencedInputs = this.templateAttributeReferencedFields;
         this.templateAttributeReferencedFields = null;
         this.descendAndCheckForNarrowedSimilarReferences(referencedInputs, () => {
-            checker.visitAll$1(this, template.children);
-            checker.visitAll$1(this, template.references);
-            checker.visitAll$1(this, template.variables);
+            compiler.visitAll(this, template.children);
+            compiler.visitAll(this, template.references);
+            compiler.visitAll(this, template.variables);
         });
     }
     visitIfBlockBranch(block) {
@@ -316,7 +317,7 @@ class TemplateReferenceVisitor extends checker.RecursiveVisitor$1 {
  * This resolution is important to be able to migrate references to inputs
  * that will be migrated to signal inputs.
  */
-class TemplateExpressionReferenceVisitor extends checker.RecursiveAstVisitor {
+class TemplateExpressionReferenceVisitor extends compiler.RecursiveAstVisitor {
     typeChecker;
     templateTypeChecker;
     componentClass;
@@ -382,7 +383,7 @@ class TemplateExpressionReferenceVisitor extends checker.RecursiveAstVisitor {
             !this.fieldNamesToConsiderForReferenceLookup.has(ast.name)) {
             return;
         }
-        const isWrite = !!(ast instanceof checker.PropertyWrite ||
+        const isWrite = !!(ast instanceof compiler.PropertyWrite ||
             (this.activeTmplAstNode && isTwoWayBindingNode(this.activeTmplAstNode)));
         this._checkAccessViaTemplateTypeCheckBlock(ast, isWrite, astPath) ||
             this._checkAccessViaOwningComponentClassType(ast, isWrite, astPath);
@@ -459,9 +460,9 @@ class TemplateExpressionReferenceVisitor extends checker.RecursiveAstVisitor {
     _isPartOfNarrowingTernary(read) {
         // Note: We do not safe check that the reads are fully matching 1:1. This is acceptable
         // as worst case we just skip an input from being migrated. This is very unlikely too.
-        return this.insideConditionalExpressionsWithReads.some((r) => (r instanceof checker.PropertyRead ||
-            r instanceof checker.PropertyWrite ||
-            r instanceof checker.SafePropertyRead) &&
+        return this.insideConditionalExpressionsWithReads.some((r) => (r instanceof compiler.PropertyRead ||
+            r instanceof compiler.PropertyWrite ||
+            r instanceof compiler.SafePropertyRead) &&
             r.name === read.name);
     }
 }
@@ -469,18 +470,18 @@ class TemplateExpressionReferenceVisitor extends checker.RecursiveAstVisitor {
  * Emulates an access to a given field using the TypeScript `ts.Type`
  * of the given class. The resolved symbol of the access is returned.
  */
-function traverseReceiverAndLookupSymbol(readOrWrite, componentClass, checker$1) {
+function traverseReceiverAndLookupSymbol(readOrWrite, componentClass, checker) {
     const path = [readOrWrite.name];
     let node = readOrWrite;
-    while (node.receiver instanceof checker.PropertyRead || node.receiver instanceof checker.PropertyWrite) {
+    while (node.receiver instanceof compiler.PropertyRead || node.receiver instanceof compiler.PropertyWrite) {
         node = node.receiver;
         path.unshift(node.name);
     }
-    if (!(node.receiver instanceof checker.ImplicitReceiver || node.receiver instanceof checker.ThisReceiver)) {
+    if (!(node.receiver instanceof compiler.ImplicitReceiver || node.receiver instanceof compiler.ThisReceiver)) {
         return null;
     }
-    const classType = checker$1.getTypeAtLocation(componentClass.name);
-    return (lookupPropertyAccess(checker$1, classType, path, {
+    const classType = checker.getTypeAtLocation(componentClass.name);
+    return (lookupPropertyAccess(checker, classType, path, {
         // Necessary to avoid breaking the resolution if there is
         // some narrowing involved. E.g. `myClass ? myClass.input`.
         ignoreNullability: true,
@@ -488,8 +489,8 @@ function traverseReceiverAndLookupSymbol(readOrWrite, componentClass, checker$1)
 }
 /** Whether the given node refers to a two-way binding AST node. */
 function isTwoWayBindingNode(node) {
-    return ((node instanceof checker.BoundAttribute && node.type === checker.BindingType.TwoWay) ||
-        (node instanceof checker.BoundEvent && node.type === checker.ParsedEventType.TwoWay));
+    return ((node instanceof compiler.BoundAttribute && node.type === compiler.BindingType.TwoWay) ||
+        (node instanceof compiler.BoundEvent && node.type === compiler.ParsedEventType.TwoWay));
 }
 
 /** Possible types of references to known fields detected. */
@@ -581,11 +582,11 @@ function identifyHostBindingReferences(node, programInfo, checker$1, reflector,
         if (!isPropertyBinding && !isEventBinding) {
             continue;
         }
-        const parser = checker.makeBindingParser();
-        const sourceSpan = new checker.ParseSourceSpan(
+        const parser = compiler.makeBindingParser();
+        const sourceSpan = new compiler.ParseSourceSpan(
         // Fake source span to keep parsing offsets zero-based.
         // We then later combine these with the expression TS node offsets.
-        new checker.ParseLocation({ content: '', url: '' }, 0, 0, 0), new checker.ParseLocation({ content: '', url: '' }, 0, 0, 0));
+        new compiler.ParseLocation({ content: '', url: '' }, 0, 0, 0), new compiler.ParseLocation({ content: '', url: '' }, 0, 0, 0));
         const name = rawName.substring(1, rawName.length - 1);
         let parsed = undefined;
         if (isEventBinding) {
@@ -649,7 +650,7 @@ function attemptExtractTemplateDefinition(node, checker$1, reflector, resourceLo
             return {
                 isInline: true,
                 expression: templateProp,
-                interpolationConfig: checker.DEFAULT_INTERPOLATION_CONFIG,
+                interpolationConfig: compiler.DEFAULT_INTERPOLATION_CONFIG,
                 preserveWhitespaces: false,
                 resolvedTemplateUrl: containingFile,
                 templateUrl: containingFile,
@@ -663,7 +664,7 @@ function attemptExtractTemplateDefinition(node, checker$1, reflector, resourceLo
             if (typeof templateUrl === 'string') {
                 return {
                     isInline: false,
-                    interpolationConfig: checker.DEFAULT_INTERPOLATION_CONFIG,
+                    interpolationConfig: compiler.DEFAULT_INTERPOLATION_CONFIG,
                     preserveWhitespaces: false,
                     templateUrlExpression: templateUrlProp,
                     templateUrl,