@angular/core 19.0.0-next.10 → 19.0.0-next.11

package/schematics/bundles/{group_replacements-1f48eff7.js → index-f7b283e6.js}

@@ -1,20 +1,18 @@
 'use strict';
 /**
- * @license Angular v19.0.0-next.10
+ * @license Angular v19.0.0-next.11
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
+var core = require('@angular-devkit/core');
+var posixPath = require('node:path/posix');
 var os = require('os');
 var ts = require('typescript');
-var checker = require('./checker-77660732.js');
-var program = require('./program-1413936a.js');
+var checker = require('./checker-51c08a1b.js');
+var program = require('./program-6e6520d8.js');
 require('path');
-var assert = require('assert');
-var leading_space = require('./leading_space-d190b83b.js');
-var core = require('@angular-devkit/core');
-var posixPath = require('node:path/posix');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -36,10 +34,9 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
+var posixPath__namespace = /*#__PURE__*/_interopNamespace(posixPath);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
-var posixPath__namespace = /*#__PURE__*/_interopNamespace(posixPath);
 
 /// <reference types="node" />
 class NgtscCompilerHost {
@@ -253,82 +250,161 @@ function getExtendedConfigPathWorker(configFile, extendsValue, host, fs) {
 }
 
 /**
- * Reasons why a field cannot be migrated.
- *
- * Higher values of incompatibility reasons indicate a more significant
- * incompatibility reason. Lower ones may be overridden by higher ones.
- * */
-exports.FieldIncompatibilityReason = void 0;
-(function (FieldIncompatibilityReason) {
-    FieldIncompatibilityReason[FieldIncompatibilityReason["OverriddenByDerivedClass"] = 1] = "OverriddenByDerivedClass";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["RedeclaredViaDerivedClassInputsArray"] = 2] = "RedeclaredViaDerivedClassInputsArray";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["TypeConflictWithBaseClass"] = 3] = "TypeConflictWithBaseClass";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["ParentIsIncompatible"] = 4] = "ParentIsIncompatible";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["DerivedIsIncompatible"] = 5] = "DerivedIsIncompatible";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["SpyOnThatOverwritesField"] = 6] = "SpyOnThatOverwritesField";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["PotentiallyNarrowedInTemplateButNoSupportYet"] = 7] = "PotentiallyNarrowedInTemplateButNoSupportYet";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["SignalInput__RequiredButNoGoodExplicitTypeExtractable"] = 8] = "SignalInput__RequiredButNoGoodExplicitTypeExtractable";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["SignalInput__QuestionMarkButNoGoodExplicitTypeExtractable"] = 9] = "SignalInput__QuestionMarkButNoGoodExplicitTypeExtractable";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["SignalQueries__QueryListProblematicFieldAccessed"] = 10] = "SignalQueries__QueryListProblematicFieldAccessed";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["SignalQueries__IncompatibleMultiUnionType"] = 11] = "SignalQueries__IncompatibleMultiUnionType";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["WriteAssignment"] = 12] = "WriteAssignment";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["Accessor"] = 13] = "Accessor";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["OutsideOfMigrationScope"] = 14] = "OutsideOfMigrationScope";
-    FieldIncompatibilityReason[FieldIncompatibilityReason["SkippedViaConfigFilter"] = 15] = "SkippedViaConfigFilter";
-})(exports.FieldIncompatibilityReason || (exports.FieldIncompatibilityReason = {}));
-/** Field reasons that cannot be ignored. */
-const nonIgnorableFieldIncompatibilities = [
-    // Outside of scope fields should not be migrated. E.g. references to inputs in `node_modules/`.
-    exports.FieldIncompatibilityReason.OutsideOfMigrationScope,
-    // Explicitly filtered fields cannot be skipped via best effort mode.
-    exports.FieldIncompatibilityReason.SkippedViaConfigFilter,
-    // There is no good output for accessor fields.
-    exports.FieldIncompatibilityReason.Accessor,
-    // There is no good output for such inputs. We can't perform "conversion".
-    exports.FieldIncompatibilityReason.SignalInput__RequiredButNoGoodExplicitTypeExtractable,
-    exports.FieldIncompatibilityReason.SignalInput__QuestionMarkButNoGoodExplicitTypeExtractable,
-];
-/** Reasons why a whole class and its fields cannot be migrated. */
-exports.ClassIncompatibilityReason = void 0;
-(function (ClassIncompatibilityReason) {
-    ClassIncompatibilityReason[ClassIncompatibilityReason["ClassManuallyInstantiated"] = 0] = "ClassManuallyInstantiated";
-    ClassIncompatibilityReason[ClassIncompatibilityReason["OwningClassReferencedInClassProperty"] = 1] = "OwningClassReferencedInClassProperty";
-})(exports.ClassIncompatibilityReason || (exports.ClassIncompatibilityReason = {}));
-/** Whether the given value refers to an field incompatibility. */
-function isFieldIncompatibility(value) {
-    return (value.reason !== undefined &&
-        value.context !== undefined &&
-        exports.FieldIncompatibilityReason.hasOwnProperty(value.reason));
-}
-/** Picks the more significant field compatibility. */
-function pickFieldIncompatibility(a, b) {
-    if (b === null) {
-        return a;
+ * Angular compiler file system implementation that leverages an
+ * CLI schematic virtual file tree.
+ */
+class DevkitMigrationFilesystem {
+    constructor(tree) {
+        this.tree = tree;
+    }
+    extname(path) {
+        return core.extname(path);
+    }
+    isRoot(path) {
+        return path === core.normalize('/');
+    }
+    isRooted(path) {
+        return this.normalize(path).startsWith('/');
+    }
+    dirname(file) {
+        return this.normalize(core.dirname(file));
+    }
+    join(basePath, ...paths) {
+        return this.normalize(core.join(basePath, ...paths));
+    }
+    relative(from, to) {
+        return this.normalize(core.relative(from, to));
+    }
+    basename(filePath, extension) {
+        return posixPath__namespace.basename(filePath, extension);
+    }
+    normalize(path) {
+        return core.normalize(path);
+    }
+    resolve(...paths) {
+        const normalizedPaths = paths.map((p) => core.normalize(p));
+        // In dev-kit, the NodeJS working directory should never be
+        // considered, so `/` is the last resort over `cwd`.
+        return this.normalize(posixPath__namespace.resolve(core.normalize('/'), ...normalizedPaths));
+    }
+    pwd() {
+        return '/';
+    }
+    isCaseSensitive() {
+        return true;
+    }
+    exists(path) {
+        return statPath(this.tree, path) !== null;
+    }
+    readFile(path) {
+        return this.tree.readText(path);
+    }
+    readFileBuffer(path) {
+        const buffer = this.tree.read(path);
+        if (buffer === null) {
+            throw new Error(`File does not exist: ${path}`);
+        }
+        return buffer;
     }
-    if (a.reason < b.reason) {
-        return b;
+    readdir(path) {
+        const dir = this.tree.getDir(path);
+        return [
+            ...dir.subdirs,
+            ...dir.subfiles,
+        ];
+    }
+    lstat(path) {
+        const stat = statPath(this.tree, path);
+        if (stat === null) {
+            throw new Error(`File does not exist for "lstat": ${path}`);
+        }
+        return stat;
+    }
+    stat(path) {
+        const stat = statPath(this.tree, path);
+        if (stat === null) {
+            throw new Error(`File does not exist for "stat": ${path}`);
+        }
+        return stat;
+    }
+    realpath(filePath) {
+        return filePath;
+    }
+    getDefaultLibLocation() {
+        return 'node_modules/typescript/lib';
+    }
+    ensureDir(path) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#ensureDir is not supported.');
+    }
+    writeFile(path, data) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#writeFile is not supported.');
+    }
+    removeFile(path) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#removeFile is not supported.');
+    }
+    copyFile(from, to) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#copyFile is not supported.');
+    }
+    moveFile(from, to) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#moveFile is not supported.');
+    }
+    removeDeep(path) {
+        // Migrations should compute replacements and not write directly.
+        throw new Error('DevkitFilesystem#removeDeep is not supported.');
+    }
+    chdir(_path) {
+        throw new Error('FileSystem#chdir is not supported.');
+    }
+    symlink() {
+        throw new Error('FileSystem#symlink is not supported.');
     }
-    return a;
 }
-
-function getMemberName(member) {
-    if (member.name === undefined) {
-        return null;
+/** Stats the given path in the virtual tree. */
+function statPath(tree, path) {
+    let fileInfo = null;
+    let dirInfo = null;
+    try {
+        fileInfo = tree.get(path);
     }
-    if (ts__default["default"].isIdentifier(member.name) || ts__default["default"].isStringLiteralLike(member.name)) {
-        return member.name.text;
+    catch (e) {
+        if (e.constructor.name === 'PathIsDirectoryException') {
+            dirInfo = tree.getDir(path);
+        }
+        else {
+            throw e;
+        }
     }
-    if (ts__default["default"].isPrivateIdentifier(member.name)) {
-        return `#${member.name.text}`;
+    if (fileInfo !== null || dirInfo !== null) {
+        return {
+            isDirectory: () => dirInfo !== null,
+            isFile: () => fileInfo !== null,
+            isSymbolicLink: () => false,
+        };
     }
     return null;
 }
 
-/** Checks whether the given node can be an `@Input()` declaration node. */
-function isInputContainerNode(node) {
-    return (((ts__default["default"].isAccessor(node) && ts__default["default"].isClassDeclaration(node.parent)) ||
-        ts__default["default"].isPropertyDeclaration(node)) &&
-        getMemberName(node) !== null);
+/**
+ * Groups the given replacements per project relative
+ * file path.
+ *
+ * This allows for simple execution of the replacements
+ * against a given file. E.g. via {@link applyTextUpdates}.
+ */
+function groupReplacementsByFile(replacements) {
+    const result = new Map();
+    for (const { projectFile, update } of replacements) {
+        if (!result.has(projectFile.rootRelativePath)) {
+            result.set(projectFile.rootRelativePath, []);
+        }
+        result.get(projectFile.rootRelativePath).push(update);
+    }
+    return result;
 }
 
 /** Code of the error raised by TypeScript when a tsconfig doesn't match any files. */
@@ -404,6 +480,20 @@ class TsurgeBaseMigration {
     }
 }
 
+/**
+ * A simpler variant of a {@link TsurgeComplexMigration} that does not
+ * fan-out into multiple workers per compilation unit to compute
+ * the final migration replacements.
+ *
+ * This is faster and less resource intensive as workers and TS programs
+ * are only ever created once.
+ *
+ * This is commonly the case when migrations are refactored to eagerly
+ * compute replacements in the analyze stage, and then leverage the
+ * global unit data to filter replacements that turned out to be "invalid".
+ */
+class TsurgeFunnelMigration extends TsurgeBaseMigration {
+}
 /**
  * Complex variant of a `Tsurge` migration.
  *
@@ -475,103 +565,76 @@ function isWithinBasePath(fs, base, path) {
 }
 
 /**
- * Detects `spyOn(dirInstance, 'myInput')` calls that likely modify
- * the input signal. There is no way to change the value inside the input signal,
- * and hence observing is not possible.
+ * Applies import manager changes, and writes them as replacements the
+ * given result array.
  */
-class SpyOnFieldPattern {
-    constructor(checker, fields) {
-        this.checker = checker;
-        this.fields = fields;
-    }
-    detect(node) {
-        if (ts__default["default"].isCallExpression(node) &&
-            ts__default["default"].isIdentifier(node.expression) &&
-            node.expression.text === 'spyOn' &&
-            node.arguments.length === 2 &&
-            ts__default["default"].isStringLiteralLike(node.arguments[1])) {
-            const spyTargetType = this.checker.getTypeAtLocation(node.arguments[0]);
-            const spyProperty = spyTargetType.getProperty(node.arguments[1].text);
-            if (spyProperty === undefined) {
-                return;
-            }
-            const fieldTarget = this.fields.attemptRetrieveDescriptorFromSymbol(spyProperty);
-            if (fieldTarget === null) {
-                return;
-            }
-            this.fields.markFieldIncompatible(fieldTarget, {
-                reason: exports.FieldIncompatibilityReason.SpyOnThatOverwritesField,
-                context: node,
-            });
+function applyImportManagerChanges(importManager, replacements, sourceFiles, info) {
+    const { newImports, updatedImports, deletedImports } = importManager.finalize();
+    const printer = ts__default["default"].createPrinter({});
+    const pathToFile = new Map(sourceFiles.map((s) => [s.fileName, s]));
+    // Capture new imports
+    newImports.forEach((newImports, fileName) => {
+        newImports.forEach((newImport) => {
+            const printedImport = printer.printNode(ts__default["default"].EmitHint.Unspecified, newImport, pathToFile.get(fileName));
+            replacements.push(new Replacement(projectFile(checker.absoluteFrom(fileName), info), new TextUpdate({ position: 0, end: 0, toInsert: `${printedImport}\n` })));
+        });
+    });
+    // Capture updated imports
+    for (const [oldBindings, newBindings] of updatedImports.entries()) {
+        // The import will be generated as multi-line if it already is multi-line,
+        // or if the number of elements significantly increased and it previously
+        // consisted of very few specifiers.
+        const isMultiline = oldBindings.getText().includes('\n') ||
+            (newBindings.elements.length >= 6 && oldBindings.elements.length <= 3);
+        const hasSpaceBetweenBraces = oldBindings.getText().startsWith('{ ');
+        let formatFlags = ts__default["default"].ListFormat.NamedImportsOrExportsElements |
+            ts__default["default"].ListFormat.Indented |
+            ts__default["default"].ListFormat.Braces |
+            ts__default["default"].ListFormat.PreserveLines |
+            (isMultiline ? ts__default["default"].ListFormat.MultiLine : ts__default["default"].ListFormat.SingleLine);
+        if (hasSpaceBetweenBraces) {
+            formatFlags |= ts__default["default"].ListFormat.SpaceBetweenBraces;
+        }
+        else {
+            formatFlags &= ~ts__default["default"].ListFormat.SpaceBetweenBraces;
         }
+        const printedBindings = printer.printList(formatFlags, newBindings.elements, oldBindings.getSourceFile());
+        replacements.push(new Replacement(projectFile(oldBindings.getSourceFile(), info), new TextUpdate({
+            position: oldBindings.getStart(),
+            end: oldBindings.getEnd(),
+            // TS uses four spaces as indent. We migrate to two spaces as we
+            // assume this to be more common.
+            toInsert: printedBindings.replace(/^ {4}/gm, '  '),
+        })));
+    }
+    // Update removed imports
+    for (const removedImport of deletedImports) {
+        replacements.push(new Replacement(projectFile(removedImport.getSourceFile(), info), new TextUpdate({
+            position: removedImport.getStart(),
+            end: removedImport.getEnd(),
+            toInsert: '',
+        })));
     }
 }
 
-/**
- * Phase where problematic patterns are detected and advise
- * the migration to skip certain inputs.
- *
- * For example, detects classes that are instantiated manually. Those
- * cannot be migrated as `input()` requires an injection context.
- *
- * In addition, spying onto an input may be problematic- so we skip migrating
- * such.
- */
-function checkIncompatiblePatterns(inheritanceGraph, checker$1, groupedTsAstVisitor, fields, getAllClassesWithKnownFields) {
-    const inputClassSymbolsToClass = new Map();
-    for (const knownFieldClass of getAllClassesWithKnownFields()) {
-        const classSymbol = checker$1.getTypeAtLocation(knownFieldClass).symbol;
-        assert__default["default"](classSymbol != null, 'Expected a symbol to exist for the container of known field class.');
-        assert__default["default"](classSymbol.valueDeclaration !== undefined, 'Expected declaration to exist for known field class.');
-        assert__default["default"](ts__default["default"].isClassDeclaration(classSymbol.valueDeclaration), 'Expected declaration to be a class.');
-        // track class symbol for derived class checks.
-        inputClassSymbolsToClass.set(classSymbol, classSymbol.valueDeclaration);
-    }
-    const spyOnPattern = new SpyOnFieldPattern(checker$1, fields);
-    const visitor = (node) => {
-        // Check for manual class instantiations.
-        if (ts__default["default"].isNewExpression(node) && ts__default["default"].isIdentifier(checker.unwrapExpression(node.expression))) {
-            let newTarget = checker$1.getSymbolAtLocation(checker.unwrapExpression(node.expression));
-            // Plain identifier references can point to alias symbols (e.g. imports).
-            if (newTarget !== undefined && newTarget.flags & ts__default["default"].SymbolFlags.Alias) {
-                newTarget = checker$1.getAliasedSymbol(newTarget);
-            }
-            if (newTarget && inputClassSymbolsToClass.has(newTarget)) {
-                fields.markClassIncompatible(inputClassSymbolsToClass.get(newTarget), exports.ClassIncompatibilityReason.ClassManuallyInstantiated);
-            }
-        }
-        // Detect `spyOn` problematic usages and record them.
-        spyOnPattern.detect(node);
-        const insidePropertyDeclaration = groupedTsAstVisitor.state.insidePropertyDeclaration;
-        // Check for problematic class references inside property declarations.
-        // These are likely problematic, causing type conflicts, if the containing
-        // class inherits a non-input member with the same name.
-        // Suddenly the derived class changes its signature, but the base class may not.
-        problematicReferencesCheck: if (insidePropertyDeclaration !== null &&
-            ts__default["default"].isIdentifier(node) &&
-            insidePropertyDeclaration.parent.heritageClauses !== undefined) {
-            let newTarget = checker$1.getSymbolAtLocation(checker.unwrapExpression(node));
-            // Plain identifier references can point to alias symbols (e.g. imports).
-            if (newTarget !== undefined && newTarget.flags & ts__default["default"].SymbolFlags.Alias) {
-                newTarget = checker$1.getAliasedSymbol(newTarget);
-            }
-            if (newTarget && inputClassSymbolsToClass.has(newTarget)) {
-                const memberName = getMemberName(insidePropertyDeclaration);
-                if (memberName === null) {
-                    break problematicReferencesCheck;
-                }
-                const { derivedMembers, inherited } = inheritanceGraph.checkOverlappingMembers(insidePropertyDeclaration.parent, insidePropertyDeclaration, memberName);
-                // Member is not inherited, or derived.
-                // Hence the reference is unproblematic and is expected to not
-                // cause any type conflicts.
-                if (derivedMembers.length === 0 && inherited === undefined) {
-                    break problematicReferencesCheck;
-                }
-                fields.markClassIncompatible(inputClassSymbolsToClass.get(newTarget), exports.ClassIncompatibilityReason.OwningClassReferencedInClassProperty);
-            }
-        }
-    };
-    groupedTsAstVisitor.register(visitor);
+function getMemberName(member) {
+    if (member.name === undefined) {
+        return null;
+    }
+    if (ts__default["default"].isIdentifier(member.name) || ts__default["default"].isStringLiteralLike(member.name)) {
+        return member.name.text;
+    }
+    if (ts__default["default"].isPrivateIdentifier(member.name)) {
+        return `#${member.name.text}`;
+    }
+    return null;
+}
+
+/** Checks whether the given node can be an `@Input()` declaration node. */
+function isInputContainerNode(node) {
+    return (((ts__default["default"].isAccessor(node) && ts__default["default"].isClassDeclaration(node.parent)) ||
+        ts__default["default"].isPropertyDeclaration(node)) &&
+        getMemberName(node) !== null);
 }
 
 /**
@@ -29625,7 +29688,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-new Version('19.0.0-next.10');
+new Version('19.0.0-next.11');
 
 var _VisitorMode;
 (function (_VisitorMode) {
@@ -29987,31 +30050,31 @@ function isTwoWayBindingNode(node) {
 }
 
 /** Possible types of references to known fields detected. */
-var ReferenceKind;
+exports.ReferenceKind = void 0;
 (function (ReferenceKind) {
     ReferenceKind[ReferenceKind["InTemplate"] = 0] = "InTemplate";
     ReferenceKind[ReferenceKind["InHostBinding"] = 1] = "InHostBinding";
     ReferenceKind[ReferenceKind["TsReference"] = 2] = "TsReference";
     ReferenceKind[ReferenceKind["TsClassTypeReference"] = 3] = "TsClassTypeReference";
-})(ReferenceKind || (ReferenceKind = {}));
+})(exports.ReferenceKind || (exports.ReferenceKind = {}));
 /** Whether the given reference is a TypeScript reference. */
 function isTsReference(ref) {
-    return ref.kind === ReferenceKind.TsReference;
+    return ref.kind === exports.ReferenceKind.TsReference;
 }
 /** Whether the given reference is a template reference. */
 function isTemplateReference(ref) {
-    return ref.kind === ReferenceKind.InTemplate;
+    return ref.kind === exports.ReferenceKind.InTemplate;
 }
 /** Whether the given reference is a host binding reference. */
 function isHostBindingReference(ref) {
-    return ref.kind === ReferenceKind.InHostBinding;
+    return ref.kind === exports.ReferenceKind.InHostBinding;
 }
 /**
  * Whether the given reference is a TypeScript `ts.Type` reference
  * to a class containing known fields.
  */
 function isTsClassTypeReference(ref) {
-    return ref.kind === ReferenceKind.TsClassTypeReference;
+    return ref.kind === exports.ReferenceKind.TsClassTypeReference;
 }
 
 /**
@@ -30099,7 +30162,7 @@ function identifyHostBindingReferences(node, programInfo, checker$1, reflector,
     }
     for (const ref of expressionResult) {
         result.references.push({
-            kind: ReferenceKind.InHostBinding,
+            kind: exports.ReferenceKind.InHostBinding,
             from: {
                 read: ref.read,
                 readAstPath: ref.readAstPath,
@@ -30199,7 +30262,7 @@ function identifyTemplateReferences(programInfo, node, reflector, checker$1, eva
                 continue;
             }
             result.references.push({
-                kind: ReferenceKind.InTemplate,
+                kind: exports.ReferenceKind.InTemplate,
                 from: {
                     read: res.read,
                     readAstPath: res.readAstPath,
@@ -30385,7 +30448,7 @@ function identifyPotentialTypeScriptReference(node, programInfo, checker, knownF
         writeBinaryOperators.includes(accessParent.operatorToken.kind);
     // track accesses from source files to known fields.
     result.references.push({
-        kind: ReferenceKind.TsReference,
+        kind: exports.ReferenceKind.TsReference,
         from: {
             node,
             file: projectFile(node.getSourceFile(), programInfo),
@@ -30448,7 +30511,7 @@ function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflecto
         const partialDirectiveInCatalyst = partialDirectiveCatalystTracker.detect(node);
         if (partialDirectiveInCatalyst !== null) {
             result.references.push({
-                kind: ReferenceKind.TsClassTypeReference,
+                kind: exports.ReferenceKind.TsClassTypeReference,
                 from: {
                     file: projectFile(partialDirectiveInCatalyst.referenceNode.getSourceFile(), programInfo),
                     node: partialDirectiveInCatalyst.referenceNode,
@@ -30468,1488 +30531,23 @@ function createFindAllSourceFileReferencesVisitor(programInfo, checker, reflecto
     };
 }
 
-/** Gets all types that are inherited (implemented or extended). */
-function getInheritedTypes(node, checker) {
-    if (node.heritageClauses === undefined) {
-        return [];
-    }
-    const heritageTypes = [];
-    for (const heritageClause of node.heritageClauses) {
-        for (const typeNode of heritageClause.types) {
-            heritageTypes.push(checker.getTypeFromTypeNode(typeNode));
-        }
-    }
-    return heritageTypes;
-}
-
-/**
- * Inheritance graph tracks edges between classes that describe
- * heritage.
- *
- * This graph is helpful for efficient lookups whether e.g. an input
- * is overridden, or inherited etc. This is helpful when detecting
- * and propagating input incompatibility statuses.
- */
-class InheritanceGraph {
-    constructor(checker) {
-        this.checker = checker;
-        /** Maps nodes to their parent nodes. */
-        this.classToParents = new Map();
-        /** Maps nodes to their derived nodes. */
-        this.parentToChildren = new Map();
-        /** All classes seen participating in inheritance chains. */
-        this.allClassesInInheritance = new Set();
-    }
-    /** Registers a given class in the graph. */
-    registerClass(clazz, parents) {
-        this.classToParents.set(clazz, parents);
-        this.allClassesInInheritance.add(clazz);
-        for (const parent of parents) {
-            this.allClassesInInheritance.add(parent);
-            if (!this.parentToChildren.has(parent)) {
-                this.parentToChildren.set(parent, []);
-            }
-            this.parentToChildren.get(parent).push(clazz);
-        }
-    }
-    /**
-     * Checks if the given class has overlapping members, either
-     * inherited or derived.
-     *
-     * @returns Symbols of the inherited or derived members, if they exist.
-     */
-    checkOverlappingMembers(clazz, member, memberName) {
-        const inheritedTypes = (this.classToParents.get(clazz) ?? []).map((c) => this.checker.getTypeAtLocation(c));
-        const derivedLeafs = this._traceDerivedChainToLeafs(clazz).map((c) => this.checker.getTypeAtLocation(c));
-        const inheritedMember = inheritedTypes
-            .map((t) => t.getProperty(memberName))
-            .find((m) => m !== undefined);
-        const derivedMembers = derivedLeafs
-            .map((t) => t.getProperty(memberName))
-            // Skip members that point back to the current class element. The derived type
-            // might look up back to our starting point— which we ignore.
-            .filter((m) => m !== undefined && m.valueDeclaration !== member);
-        return { inherited: inheritedMember, derivedMembers };
-    }
-    /** Gets all leaf derived classes that extend from the given class. */
-    _traceDerivedChainToLeafs(clazz) {
-        const queue = [clazz];
-        const leafs = [];
-        while (queue.length) {
-            const node = queue.shift();
-            if (!this.parentToChildren.has(node)) {
-                if (node !== clazz) {
-                    leafs.push(node);
-                }
-                continue;
-            }
-            queue.push(...this.parentToChildren.get(node));
-        }
-        return leafs;
-    }
-    /** Gets all derived classes of the given node. */
-    traceDerivedClasses(clazz) {
-        const queue = [clazz];
-        const derived = [];
-        while (queue.length) {
-            const node = queue.shift();
-            if (node !== clazz) {
-                derived.push(node);
-            }
-            if (!this.parentToChildren.has(node)) {
-                continue;
-            }
-            queue.push(...this.parentToChildren.get(node));
-        }
-        return derived;
-    }
-    /**
-     * Populates the graph.
-     *
-     * NOTE: This is expensive and should be called with caution.
-     */
-    expensivePopulate(files) {
-        for (const file of files) {
-            const visitor = (node) => {
-                if ((ts__default["default"].isClassLike(node) || ts__default["default"].isInterfaceDeclaration(node)) &&
-                    node.heritageClauses !== undefined) {
-                    const heritageTypes = getInheritedTypes(node, this.checker);
-                    const parents = heritageTypes
-                        // Interfaces participate in the graph and are not "value declarations".
-                        // Also, symbol may be undefined for unresolvable nodes.
-                        .map((t) => (t.symbol ? t.symbol.declarations?.[0] : undefined))
-                        .filter((d) => d !== undefined && (ts__default["default"].isClassLike(d) || ts__default["default"].isInterfaceDeclaration(d)));
-                    this.registerClass(node, parents);
-                }
-                ts__default["default"].forEachChild(node, visitor);
-            };
-            ts__default["default"].forEachChild(file, visitor);
-        }
-        return this;
-    }
-}
-
-/**
- * Class that allows for efficient grouping of TypeScript node AST
- * traversal.
- *
- * Allows visitors to execute in a single pass when visiting all
- * children of source files.
- */
-class GroupedTsAstVisitor {
-    constructor(files) {
-        this.files = files;
-        this.visitors = [];
-        this.doneFns = [];
-        this.state = {
-            insidePropertyDeclaration: null,
-        };
-    }
-    register(visitor, done) {
-        this.visitors.push(visitor);
-        if (done !== undefined) {
-            this.doneFns.push(done);
-        }
-    }
-    execute() {
-        const visitor = (node) => {
-            for (const v of this.visitors) {
-                v(node);
-            }
-            if (ts__default["default"].isPropertyDeclaration(node)) {
-                this.state.insidePropertyDeclaration = node;
-                ts__default["default"].forEachChild(node, visitor);
-                this.state.insidePropertyDeclaration = null;
-            }
-            else {
-                ts__default["default"].forEachChild(node, visitor);
-            }
-        };
-        for (const file of this.files) {
-            ts__default["default"].forEachChild(file, visitor);
-        }
-        for (const doneFn of this.doneFns) {
-            doneFn();
-        }
-        this.visitors = [];
-    }
-}
-
-/**
- * Phase that propagates incompatibilities to derived classes or
- * base classes. For example, consider:
- *
- * ```
- * class Base {
- *   bla = true;
- * }
- *
- * class Derived extends Base {
- *   @Input() bla = false;
- * }
- * ```
- *
- * Whenever we migrate `Derived`, the inheritance would fail
- * and result in a build breakage because `Base#bla` is not an Angular input.
- *
- * The logic here detects such cases and marks `bla` as incompatible. If `Derived`
- * would then have other derived classes as well, it would propagate the status.
- */
-function checkInheritanceOfKnownFields(inheritanceGraph, metaRegistry, fields, opts) {
-    const allInputClasses = Array.from(inheritanceGraph.allClassesInInheritance).filter((t) => ts__default["default"].isClassDeclaration(t) && opts.isClassWithKnownFields(t));
-    for (const inputClass of allInputClasses) {
-        // Note: Class parents of `inputClass` were already checked by
-        // the previous iterations (given the reverse topological sort)—
-        // hence it's safe to assume that incompatibility of parent classes will
-        // not change again, at a later time.
-        assert__default["default"](ts__default["default"].isClassDeclaration(inputClass), 'Expected input graph node to be always a class.');
-        const classFields = opts.getFieldsForClass(inputClass);
-        // Iterate through derived class chains and determine all inputs that are overridden
-        // via class metadata fields. e.g `@Component#inputs`. This is later used to mark a
-        // potential similar class input as incompatible— because those cannot be migrated.
-        const inputFieldNamesFromMetadataArray = new Set();
-        for (const derivedClasses of inheritanceGraph.traceDerivedClasses(inputClass)) {
-            const derivedMeta = ts__default["default"].isClassDeclaration(derivedClasses) && derivedClasses.name !== undefined
-                ? metaRegistry.getDirectiveMetadata(new checker.Reference(derivedClasses))
-                : null;
-            if (derivedMeta !== null && derivedMeta.inputFieldNamesFromMetadataArray !== null) {
-                derivedMeta.inputFieldNamesFromMetadataArray.forEach((b) => inputFieldNamesFromMetadataArray.add(b));
-            }
-        }
-        // Check inheritance of every input in the given "directive class".
-        inputCheck: for (const fieldDescr of classFields) {
-            const inputNode = fieldDescr.node;
-            const { derivedMembers, inherited } = inheritanceGraph.checkOverlappingMembers(inputClass, inputNode, getMemberName(inputNode));
-            // If we discover a derived, input re-declared via class metadata, then it
-            // will cause conflicts as we cannot migrate it/ nor mark it as signal-based.
-            if (fieldDescr.node.name !== undefined &&
-                (ts__default["default"].isIdentifier(fieldDescr.node.name) || ts__default["default"].isStringLiteralLike(fieldDescr.node.name)) &&
-                inputFieldNamesFromMetadataArray.has(fieldDescr.node.name.text)) {
-                fields.captureUnknownDerivedField(fieldDescr);
-            }
-            for (const derived of derivedMembers) {
-                const derivedInput = fields.attemptRetrieveDescriptorFromSymbol(derived);
-                if (derivedInput !== null) {
-                    // Note: We always track dependencies from the child to the parent,
-                    // so skip here for now.
-                    continue;
-                }
-                // If we discover a derived, non-input member, then it will cause
-                // conflicts, and we mark the current input as incompatible.
-                fields.captureUnknownDerivedField(fieldDescr);
-                continue inputCheck;
-            }
-            // If there is no parent, we are done. Otherwise, check the parent
-            // to either inherit or check the incompatibility with the inheritance.
-            if (inherited === undefined) {
-                continue;
-            }
-            const inheritedMemberInput = fields.attemptRetrieveDescriptorFromSymbol(inherited);
-            // Parent is not an input, and hence will conflict..
-            if (inheritedMemberInput === null) {
-                fields.captureUnknownParentField(fieldDescr);
-                continue;
-            }
-            fields.captureKnownFieldInheritanceRelationship(fieldDescr, inheritedMemberInput);
-        }
-    }
-}
-
-function removeFromUnionIfPossible(union, filter) {
-    const filtered = union.types.filter(filter);
-    if (filtered.length === union.types.length) {
-        return union;
-    }
-    // If there is only item at this point, avoid the union structure.
-    if (filtered.length === 1) {
-        return filtered[0];
-    }
-    return ts__default["default"].factory.updateUnionTypeNode(union, ts__default["default"].factory.createNodeArray(filtered));
-}
-
-/**
- * Inserts a leading string for the given node, respecting
- * indentation of the given anchor node.
- *
- * Useful for inserting TODOs.
- */
-function insertPrecedingLine(node, info, text) {
-    const leadingSpace = leading_space.getLeadingLineWhitespaceOfNode(node);
-    return new Replacement(projectFile(node.getSourceFile(), info), new TextUpdate({
-        position: node.getStart(),
-        end: node.getStart(),
-        toInsert: `${text}\n${leadingSpace}`,
-    }));
-}
-
-/**
- * Cuts the given string into lines basing around the specified
- * line length limit. This function breaks the string on a per-word basis.
- */
-function cutStringToLineLimit(str, limit) {
-    const words = str.split(' ');
-    const chunks = [];
-    let chunkIdx = 0;
-    while (words.length) {
-        // New line if we exceed limit.
-        if (chunks[chunkIdx] !== undefined && chunks[chunkIdx].length > limit) {
-            chunkIdx++;
-        }
-        // Ensure line is initialized for the given index.
-        if (chunks[chunkIdx] === undefined) {
-            chunks[chunkIdx] = '';
-        }
-        const word = words.shift();
-        const needsSpace = chunks[chunkIdx].length > 0;
-        // Insert word. Add space before, if the line already contains text.
-        chunks[chunkIdx] += `${needsSpace ? ' ' : ''}${word}`;
-    }
-    return chunks;
-}
-
-/**
- * Gets human-readable message information for the given field incompatibility.
- * This text will be used by the language service, or CLI-based migration.
- */
-function getMessageForFieldIncompatibility(reason, fieldName) {
-    switch (reason) {
-        case exports.FieldIncompatibilityReason.Accessor:
-            return {
-                short: `Accessor ${fieldName.plural} cannot be migrated as they are too complex.`,
-                extra: 'The migration potentially requires usage of `effect` or `computed`, but ' +
-                    'the intent is unclear. The migration cannot safely migrate.',
-            };
-        case exports.FieldIncompatibilityReason.OverriddenByDerivedClass:
-            return {
-                short: `The ${fieldName.single} cannot be migrated because the field is overridden by a subclass.`,
-                extra: 'The field in the subclass is not a signal, so migrating would break your build.',
-            };
-        case exports.FieldIncompatibilityReason.ParentIsIncompatible:
-            return {
-                short: `This ${fieldName.single} is inherited from a superclass, but the parent cannot be migrated.`,
-                extra: 'Migrating this field would cause your build to fail.',
-            };
-        case exports.FieldIncompatibilityReason.DerivedIsIncompatible:
-            return {
-                short: `This ${fieldName.single} cannot be migrated because the field is overridden by a subclass.`,
-                extra: 'The field in the subclass is incompatible for migration, so migrating this field would ' +
-                    'break your build.',
-            };
-        case exports.FieldIncompatibilityReason.PotentiallyNarrowedInTemplateButNoSupportYet:
-            return {
-                short: `This ${fieldName.single} is used in a control flow expression (e.g. \`@if\` or \`*ngIf\`) and ` +
-                    'migrating would break narrowing currently.',
-                extra: `In the future, Angular intends to support narrowing of signals.`,
-            };
-        case exports.FieldIncompatibilityReason.RedeclaredViaDerivedClassInputsArray:
-            return {
-                short: `The ${fieldName.single} is overridden by a subclass that cannot be migrated.`,
-                extra: `The subclass overrides this ${fieldName.single} via the \`inputs\` array in @Directive/@Component. ` +
-                    'Migrating the field would break your build because the subclass field cannot be a signal.',
-            };
-        case exports.FieldIncompatibilityReason.SignalInput__RequiredButNoGoodExplicitTypeExtractable:
-            return {
-                short: `Input is required, but the migration cannot determine a good type for the input.`,
-                extra: 'Consider adding an explicit type to make the migration possible.',
-            };
-        case exports.FieldIncompatibilityReason.SignalInput__QuestionMarkButNoGoodExplicitTypeExtractable:
-            return {
-                short: `Input is marked with a question mark. Migration could not determine a good type for the input.`,
-                extra: 'The migration needs to be able to resolve a type, so that it can include `undefined` in your type. ' +
-                    'Consider adding an explicit type to make the migration possible.',
-            };
-        case exports.FieldIncompatibilityReason.SignalQueries__QueryListProblematicFieldAccessed:
-            return {
-                short: `There are references to this query that cannot be migrated automatically.`,
-                extra: "For example, it's not possible to migrate `.changes` or `.dirty` trivially.",
-            };
-        case exports.FieldIncompatibilityReason.SignalQueries__IncompatibleMultiUnionType:
-            return {
-                short: `Query type is too complex to automatically migrate.`,
-                extra: "The new query API doesn't allow us to migrate safely without breaking your app.",
-            };
-        case exports.FieldIncompatibilityReason.SkippedViaConfigFilter:
-            return {
-                short: `This ${fieldName.single} is not part of the current migration scope.`,
-                extra: 'Skipped via migration config.',
-            };
-        case exports.FieldIncompatibilityReason.SpyOnThatOverwritesField:
-            return {
-                short: 'A jasmine `spyOn` call spies on this field. This breaks with signals.',
-                extra: `Migration cannot safely migrate as "spyOn" writes to the ${fieldName.single}. ` +
-                    `Signal ${fieldName.plural} are readonly.`,
-            };
-        case exports.FieldIncompatibilityReason.TypeConflictWithBaseClass:
-            return {
-                short: `This ${fieldName.single} overrides a field from a superclass, while the superclass ` +
-                    `field is not migrated.`,
-                extra: 'Migrating the field would break your build because of a type conflict.',
-            };
-        case exports.FieldIncompatibilityReason.WriteAssignment:
-            return {
-                short: `Your application code writes to the ${fieldName.single}. This prevents migration.`,
-                extra: `Signal ${fieldName.plural} are readonly, so migrating would break your build.`,
-            };
-        case exports.FieldIncompatibilityReason.OutsideOfMigrationScope:
-            return {
-                short: `This ${fieldName.single} is not part of any source files in your project.`,
-                extra: `The migration excludes ${fieldName.plural} if no source file declaring them was seen.`,
-            };
-    }
-}
-/**
- * Gets human-readable message information for the given class incompatibility.
- * This text will be used by the language service, or CLI-based migration.
- */
-function getMessageForClassIncompatibility(reason, fieldName) {
-    switch (reason) {
-        case exports.ClassIncompatibilityReason.OwningClassReferencedInClassProperty:
-            return {
-                short: `Class of this ${fieldName.single} is referenced in the signature of another class.`,
-                extra: 'The other class is likely typed to expect a non-migrated field, so ' +
-                    'migration is skipped to not break your build.',
-            };
-        case exports.ClassIncompatibilityReason.ClassManuallyInstantiated:
-            return {
-                short: `Class of this ${fieldName.single} is manually instantiated. ` +
-                    'This is discouraged and prevents migration',
-                extra: `Signal ${fieldName.plural} require a DI injection context. Manually instantiating ` +
-                    'breaks this requirement in some cases, so the migration is skipped.',
-            };
-    }
-}
-
-/**
- * Inserts a TODO for the incompatibility blocking the given node
- * from being migrated.
- */
-function insertTodoForIncompatibility(node, programInfo, incompatibility, fieldName) {
-    // If a field is skipped via config filter or outside migration scope, do not
-    // insert TODOs, as this could results in lots of unnecessary comments.
-    if (isFieldIncompatibility(incompatibility) &&
-        (incompatibility.reason === exports.FieldIncompatibilityReason.SkippedViaConfigFilter ||
-            incompatibility.reason === exports.FieldIncompatibilityReason.OutsideOfMigrationScope)) {
-        return [];
-    }
-    const message = isFieldIncompatibility(incompatibility)
-        ? getMessageForFieldIncompatibility(incompatibility.reason, fieldName).short
-        : getMessageForClassIncompatibility(incompatibility, fieldName).short;
-    const lines = cutStringToLineLimit(message, 70);
-    return [
-        insertPrecedingLine(node, programInfo, `// TODO: Skipped for migration because:`),
-        ...lines.map((line) => insertPrecedingLine(node, programInfo, `//  ${line}`)),
-    ];
-}
-
-/**
- * Applies import manager changes, and writes them as replacements the
- * given result array.
- */
-function applyImportManagerChanges(importManager, replacements, sourceFiles, info) {
-    const { newImports, updatedImports, deletedImports } = importManager.finalize();
-    const printer = ts__default["default"].createPrinter({});
-    const pathToFile = new Map(sourceFiles.map((s) => [s.fileName, s]));
-    // Capture new imports
-    newImports.forEach((newImports, fileName) => {
-        newImports.forEach((newImport) => {
-            const printedImport = printer.printNode(ts__default["default"].EmitHint.Unspecified, newImport, pathToFile.get(fileName));
-            replacements.push(new Replacement(projectFile(checker.absoluteFrom(fileName), info), new TextUpdate({ position: 0, end: 0, toInsert: `${printedImport}\n` })));
-        });
-    });
-    // Capture updated imports
-    for (const [oldBindings, newBindings] of updatedImports.entries()) {
-        // The import will be generated as multi-line if it already is multi-line,
-        // or if the number of elements significantly increased and it previously
-        // consisted of very few specifiers.
-        const isMultiline = oldBindings.getText().includes('\n') ||
-            (newBindings.elements.length >= 6 && oldBindings.elements.length <= 3);
-        const hasSpaceBetweenBraces = oldBindings.getText().startsWith('{ ');
-        let formatFlags = ts__default["default"].ListFormat.NamedImportsOrExportsElements |
-            ts__default["default"].ListFormat.Indented |
-            ts__default["default"].ListFormat.Braces |
-            ts__default["default"].ListFormat.PreserveLines |
-            (isMultiline ? ts__default["default"].ListFormat.MultiLine : ts__default["default"].ListFormat.SingleLine);
-        if (hasSpaceBetweenBraces) {
-            formatFlags |= ts__default["default"].ListFormat.SpaceBetweenBraces;
-        }
-        else {
-            formatFlags &= ~ts__default["default"].ListFormat.SpaceBetweenBraces;
-        }
-        const printedBindings = printer.printList(formatFlags, newBindings.elements, oldBindings.getSourceFile());
-        replacements.push(new Replacement(projectFile(oldBindings.getSourceFile(), info), new TextUpdate({
-            position: oldBindings.getStart(),
-            end: oldBindings.getEnd(),
-            // TS uses four spaces as indent. We migrate to two spaces as we
-            // assume this to be more common.
-            toInsert: printedBindings.replace(/^ {4}/gm, '  '),
-        })));
-    }
-    // Update removed imports
-    for (const removedImport of deletedImports) {
-        replacements.push(new Replacement(projectFile(removedImport.getSourceFile(), info), new TextUpdate({
-            position: removedImport.getStart(),
-            end: removedImport.getEnd(),
-            toInsert: '',
-        })));
-    }
-}
-
-/** Whether the given node is a descendant of the given ancestor. */
-function isNodeDescendantOf(node, ancestor) {
-    while (node) {
-        if (node === ancestor)
-            return true;
-        node = node.parent;
-    }
-    return false;
-}
-
-/** Symbol that can be used to mark a variable as reserved, synthetically. */
-const ReservedMarker = Symbol();
-/**
- * Gets whether the given identifier name is free for use in the
- * given location, avoiding shadowed variable names.
- *
- */
-function isIdentifierFreeInScope(name, location) {
-    const startContainer = findClosestParentLocalsContainer(location);
-    assert__default["default"](startContainer !== undefined, 'Expecting a locals container.');
-    // Traverse up and check for potential collisions.
-    let container = startContainer;
-    let firstNextContainer = undefined;
-    while (container !== undefined) {
-        if (!isIdentifierFreeInContainer(name, container)) {
-            return null;
-        }
-        if (firstNextContainer === undefined && container.nextContainer !== undefined) {
-            firstNextContainer = container.nextContainer;
-        }
-        container = findClosestParentLocalsContainer(container.parent);
-    }
-    // Check descendent local containers to avoid shadowing variables.
-    // Note that this is not strictly needed, but it's helping avoid
-    // some lint errors, like TSLint's no shadowed variables.
-    container = firstNextContainer;
-    while (container && isNodeDescendantOf(container, startContainer)) {
-        if (!isIdentifierFreeInContainer(name, container)) {
-            return null;
-        }
-        container = container.nextContainer;
-    }
-    return { container: startContainer };
-}
-/** Finds the closest parent locals container. */
-function findClosestParentLocalsContainer(node) {
-    return ts__default["default"].findAncestor(node, isLocalsContainer);
-}
-/** Whether the given identifier is free in the given locals container. */
-function isIdentifierFreeInContainer(name, container) {
-    if (container.locals === undefined || !container.locals.has(name)) {
-        return true;
-    }
-    // We consider alias symbols as locals conservatively.
-    // Note: This check is similar to the check by the TypeScript emitter.
-    // typescript/stable/src/compiler/emitter.ts;l=5436;rcl=651008033
-    const local = container.locals.get(name);
-    return (local !== ReservedMarker &&
-        !(local.flags & (ts__default["default"].SymbolFlags.Value | ts__default["default"].SymbolFlags.ExportValue | ts__default["default"].SymbolFlags.Alias)));
-}
-/**
- * Whether the given node can contain local variables.
- *
- * Note: This is similar to TypeScript's `canHaveLocals` internal helper.
- * typescript/stable/src/compiler/utilitiesPublic.ts;l=2265;rcl=651008033
- */
-function isLocalsContainer(node) {
-    switch (node.kind) {
-        case ts__default["default"].SyntaxKind.ArrowFunction:
-        case ts__default["default"].SyntaxKind.Block:
-        case ts__default["default"].SyntaxKind.CallSignature:
-        case ts__default["default"].SyntaxKind.CaseBlock:
-        case ts__default["default"].SyntaxKind.CatchClause:
-        case ts__default["default"].SyntaxKind.ClassStaticBlockDeclaration:
-        case ts__default["default"].SyntaxKind.ConditionalType:
-        case ts__default["default"].SyntaxKind.Constructor:
-        case ts__default["default"].SyntaxKind.ConstructorType:
-        case ts__default["default"].SyntaxKind.ConstructSignature:
-        case ts__default["default"].SyntaxKind.ForStatement:
-        case ts__default["default"].SyntaxKind.ForInStatement:
-        case ts__default["default"].SyntaxKind.ForOfStatement:
-        case ts__default["default"].SyntaxKind.FunctionDeclaration:
-        case ts__default["default"].SyntaxKind.FunctionExpression:
-        case ts__default["default"].SyntaxKind.FunctionType:
-        case ts__default["default"].SyntaxKind.GetAccessor:
-        case ts__default["default"].SyntaxKind.IndexSignature:
-        case ts__default["default"].SyntaxKind.JSDocCallbackTag:
-        case ts__default["default"].SyntaxKind.JSDocEnumTag:
-        case ts__default["default"].SyntaxKind.JSDocFunctionType:
-        case ts__default["default"].SyntaxKind.JSDocSignature:
-        case ts__default["default"].SyntaxKind.JSDocTypedefTag:
-        case ts__default["default"].SyntaxKind.MappedType:
-        case ts__default["default"].SyntaxKind.MethodDeclaration:
-        case ts__default["default"].SyntaxKind.MethodSignature:
-        case ts__default["default"].SyntaxKind.ModuleDeclaration:
-        case ts__default["default"].SyntaxKind.SetAccessor:
-        case ts__default["default"].SyntaxKind.SourceFile:
-        case ts__default["default"].SyntaxKind.TypeAliasDeclaration:
-            return true;
-        default:
-            return false;
-    }
-}
-
-/**
- * Helper that can generate unique identifier names at a
- * given location.
- *
- * Used for generating unique names to extract input reads
- * to support narrowing.
- */
-class UniqueNamesGenerator {
-    constructor(fallbackSuffixes) {
-        this.fallbackSuffixes = fallbackSuffixes;
-    }
-    generate(base, location) {
-        const checkNameAndClaimIfAvailable = (name) => {
-            const freeInfo = isIdentifierFreeInScope(name, location);
-            if (freeInfo === null) {
-                return false;
-            }
-            // Claim the locals to avoid conflicts with future generations.
-            freeInfo.container.locals ??= new Map();
-            freeInfo.container.locals.set(name, ReservedMarker);
-            return true;
-        };
-        // Check the base name. Ideally, we'd use this one.
-        if (checkNameAndClaimIfAvailable(base)) {
-            return base;
-        }
-        // Try any of the possible suffixes.
-        for (const suffix of this.fallbackSuffixes) {
-            const name = `${base}${suffix}`;
-            if (checkNameAndClaimIfAvailable(name)) {
-                return name;
-            }
-        }
-        // Worst case, suffix the base name with a unique number until
-        // we find an available name.
-        let name = null;
-        let counter = 1;
-        do {
-            name = `${base}_${counter++}`;
-        } while (!checkNameAndClaimIfAvailable(name));
-        return name;
-    }
-}
-
-/**
- * Creates replacements to insert the given statement as
- * first statement into the arrow function.
- *
- * The arrow function is converted to a block-based arrow function
- * that can hold multiple statements. The original expression is
- * simply returned like before.
- */
-function createNewBlockToInsertVariable(node, file, toInsert) {
-    const sf = node.getSourceFile();
-    // For indentation, we traverse up and find the earliest statement.
-    // This node is most of the time a good candidate for acceptable
-    // indentation of a new block.
-    const spacingNode = ts__default["default"].findAncestor(node, ts__default["default"].isStatement) ?? node.parent;
-    const { character } = ts__default["default"].getLineAndCharacterOfPosition(sf, spacingNode.getStart());
-    const blockSpace = ' '.repeat(character);
-    const contentSpace = ' '.repeat(character + 2);
-    return [
-        // Delete leading whitespace of the concise body.
-        new Replacement(file, new TextUpdate({
-            position: node.body.getFullStart(),
-            end: node.body.getStart(),
-            toInsert: '',
-        })),
-        // Insert leading block braces, and `toInsert` content.
-        // Wrap the previous expression in a return now.
-        new Replacement(file, new TextUpdate({
-            position: node.body.getStart(),
-            end: node.body.getStart(),
-            toInsert: ` {\n${contentSpace}${toInsert}\n${contentSpace}return `,
-        })),
-        // Add trailing brace.
-        new Replacement(file, new TextUpdate({
-            position: node.body.getEnd(),
-            end: node.body.getEnd(),
-            toInsert: `;\n${blockSpace}}`,
-        })),
-    ];
-}
-
-/**
- * Migrates a binding element that refers to an Angular input.
- *
- * E.g. `const {myInput} = this`.
- *
- * For references in binding elements, we extract the element into a variable
- * where we unwrap the input. This ensures narrowing naturally works in subsequent
- * places, and we also don't need to detect potential aliases.
- *
- * ```ts
- *   const {myInput} = this;
- *   // turns into
- *   const {myInput: myInputValue} = this;
- *   const myInput = myInputValue();
- * ```
- */
-function migrateBindingElementInputReference(tsReferencesInBindingElements, info, replacements, printer) {
-    const nameGenerator = new UniqueNamesGenerator(['Input', 'Signal', 'Ref']);
-    for (const reference of tsReferencesInBindingElements) {
-        const bindingElement = reference.parent;
-        const bindingDecl = getBindingElementDeclaration(bindingElement);
-        const sourceFile = bindingElement.getSourceFile();
-        const file = projectFile(sourceFile, info);
-        const inputFieldName = bindingElement.propertyName ?? bindingElement.name;
-        assert__default["default"](!ts__default["default"].isObjectBindingPattern(inputFieldName) && !ts__default["default"].isArrayBindingPattern(inputFieldName), 'Property of binding element cannot be another pattern.');
-        const tmpName = nameGenerator.generate(reference.text, bindingElement);
-        // Only use the temporary name, if really needed. A temporary name is needed if
-        // the input field simply aliased via the binding element, or if the exposed identifier
-        // is a string-literal like.
-        const useTmpNameForInputField = !ts__default["default"].isObjectBindingPattern(bindingElement.name) || !ts__default["default"].isIdentifier(inputFieldName);
-        const propertyName = useTmpNameForInputField ? inputFieldName : undefined;
-        const exposedName = useTmpNameForInputField
-            ? ts__default["default"].factory.createIdentifier(tmpName)
-            : inputFieldName;
-        const newBindingToAccessInputField = ts__default["default"].factory.updateBindingElement(bindingElement, bindingElement.dotDotDotToken, propertyName, exposedName, bindingElement.initializer);
-        const temporaryVariableReplacements = insertTemporaryVariableForBindingElement(bindingDecl, file, `const ${bindingElement.name.getText()} = ${exposedName.text}();`);
-        if (temporaryVariableReplacements === null) {
-            console.error(`Could not migrate reference ${reference.text} in ${file.rootRelativePath}`);
-            continue;
-        }
-        replacements.push(new Replacement(file, new TextUpdate({
-            position: bindingElement.getStart(),
-            end: bindingElement.getEnd(),
-            toInsert: printer.printNode(ts__default["default"].EmitHint.Unspecified, newBindingToAccessInputField, sourceFile),
-        })), ...temporaryVariableReplacements);
-    }
-}
-/**
- * Inserts the given code snippet after the given variable or
- * parameter declaration.
- *
- * If this is a parameter of an arrow function, a block may be
- * added automatically.
- */
-function insertTemporaryVariableForBindingElement(expansionDecl, file, toInsert) {
-    const sf = expansionDecl.getSourceFile();
-    const parent = expansionDecl.parent;
-    // The snippet is simply inserted after the variable declaration.
-    // The other case of a variable declaration inside a catch clause is handled
-    // below.
-    if (ts__default["default"].isVariableDeclaration(expansionDecl) && ts__default["default"].isVariableDeclarationList(parent)) {
-        const leadingSpaceCount = ts__default["default"].getLineAndCharacterOfPosition(sf, parent.getStart()).character;
-        const leadingSpace = ' '.repeat(leadingSpaceCount);
-        const statement = parent.parent;
-        return [
-            new Replacement(file, new TextUpdate({
-                position: statement.getEnd(),
-                end: statement.getEnd(),
-                toInsert: `\n${leadingSpace}${toInsert}`,
-            })),
-        ];
-    }
-    // If we are dealing with a object expansion inside a parameter of
-    // a function-like declaration w/ block, add the variable as the first
-    // node inside the block.
-    const bodyBlock = getBodyBlockOfNode(parent);
-    if (bodyBlock !== null) {
-        const firstElementInBlock = bodyBlock.statements[0];
-        const spaceReferenceNode = firstElementInBlock ?? bodyBlock;
-        const spaceOffset = firstElementInBlock !== undefined ? 0 : 2;
-        const leadingSpaceCount = ts__default["default"].getLineAndCharacterOfPosition(sf, spaceReferenceNode.getStart()).character + spaceOffset;
-        const leadingSpace = ' '.repeat(leadingSpaceCount);
-        return [
-            new Replacement(file, new TextUpdate({
-                position: bodyBlock.getStart() + 1,
-                end: bodyBlock.getStart() + 1,
-                toInsert: `\n${leadingSpace}${toInsert}`,
-            })),
-        ];
-    }
-    // Other cases where we see an arrow function without a block.
-    // We need to create one now.
-    if (ts__default["default"].isArrowFunction(parent) && !ts__default["default"].isBlock(parent.body)) {
-        return createNewBlockToInsertVariable(parent, file, toInsert);
-    }
-    return null;
-}
-/** Gets the body block of a given node, if available. */
-function getBodyBlockOfNode(node) {
-    if ((ts__default["default"].isMethodDeclaration(node) ||
-        ts__default["default"].isFunctionDeclaration(node) ||
-        ts__default["default"].isGetAccessorDeclaration(node) ||
-        ts__default["default"].isConstructorDeclaration(node) ||
-        ts__default["default"].isArrowFunction(node)) &&
-        node.body !== undefined &&
-        ts__default["default"].isBlock(node.body)) {
-        return node.body;
-    }
-    if (ts__default["default"].isCatchClause(node.parent)) {
-        return node.parent.block;
-    }
-    return null;
-}
-
-/**
- * Whether the given node represents a control flow container boundary.
- * E.g. variables cannot be narrowed when descending into children of `node`.
- */
-function isControlFlowBoundary(node) {
-    return ((ts__default["default"].isFunctionLike(node) && !getImmediatelyInvokedFunctionExpression(node)) ||
-        node.kind === ts__default["default"].SyntaxKind.ModuleBlock ||
-        node.kind === ts__default["default"].SyntaxKind.SourceFile ||
-        node.kind === ts__default["default"].SyntaxKind.PropertyDeclaration);
-}
-/** Determines the current flow container of a given node. */
-function getControlFlowContainer(node) {
-    return ts__default["default"].findAncestor(node.parent, (node) => isControlFlowBoundary(node));
-}
-/** Checks whether the given node refers to an IIFE declaration. */
-function getImmediatelyInvokedFunctionExpression(func) {
-    if (func.kind === ts__default["default"].SyntaxKind.FunctionExpression || func.kind === ts__default["default"].SyntaxKind.ArrowFunction) {
-        let prev = func;
-        let parent = func.parent;
-        while (parent.kind === ts__default["default"].SyntaxKind.ParenthesizedExpression) {
-            prev = parent;
-            parent = parent.parent;
-        }
-        if (parent.kind === ts__default["default"].SyntaxKind.CallExpression &&
-            parent.expression === prev) {
-            return parent;
-        }
-    }
-    return undefined;
-}
-
-/** @internal */
-var FlowFlags;
-(function (FlowFlags) {
-    FlowFlags[FlowFlags["Unreachable"] = 1] = "Unreachable";
-    FlowFlags[FlowFlags["Start"] = 2] = "Start";
-    FlowFlags[FlowFlags["BranchLabel"] = 4] = "BranchLabel";
-    FlowFlags[FlowFlags["LoopLabel"] = 8] = "LoopLabel";
-    FlowFlags[FlowFlags["Assignment"] = 16] = "Assignment";
-    FlowFlags[FlowFlags["TrueCondition"] = 32] = "TrueCondition";
-    FlowFlags[FlowFlags["FalseCondition"] = 64] = "FalseCondition";
-    FlowFlags[FlowFlags["SwitchClause"] = 128] = "SwitchClause";
-    FlowFlags[FlowFlags["ArrayMutation"] = 256] = "ArrayMutation";
-    FlowFlags[FlowFlags["Call"] = 512] = "Call";
-    FlowFlags[FlowFlags["ReduceLabel"] = 1024] = "ReduceLabel";
-    FlowFlags[FlowFlags["Referenced"] = 2048] = "Referenced";
-    FlowFlags[FlowFlags["Shared"] = 4096] = "Shared";
-    FlowFlags[FlowFlags["Label"] = 12] = "Label";
-    FlowFlags[FlowFlags["Condition"] = 96] = "Condition";
-})(FlowFlags || (FlowFlags = {}));
-
-/**
- * Traverses the graph of the TypeScript flow nodes, exploring all possible branches
- * and keeps track of interesting nodes that may contribute to "narrowing".
- *
- * This allows us to figure out which nodes may be narrowed or not, and need
- * temporary variables in the migration to allowing narrowing to continue working.
- *
- * Some resources on flow nodes by TypeScript:
- * https://effectivetypescript.com/2024/03/24/flownodes/.
- */
-function traverseFlowForInterestingNodes(flow) {
-    let flowDepth = 0;
-    let interestingNodes = [];
-    const queue = new Set([flow]);
-    // Queue is evolved during iteration, and new items will be added
-    // to the end of the iteration. Effectively implementing a queue
-    // with deduping out of the box.
-    for (const flow of queue) {
-        if (++flowDepth === 2000) {
-            // We have made 2000 recursive invocations. To avoid overflowing the call stack we report an
-            // error and disable further control flow analysis in the containing function or module body.
-            return interestingNodes;
-        }
-        const flags = flow.flags;
-        if (flags & FlowFlags.Assignment) {
-            const assignment = flow;
-            queue.add(assignment.antecedent);
-            if (ts__default["default"].isVariableDeclaration(assignment.node)) {
-                interestingNodes.push(assignment.node.name);
-            }
-            else if (ts__default["default"].isBindingElement(assignment.node)) {
-                interestingNodes.push(assignment.node.name);
-            }
-            else {
-                interestingNodes.push(assignment.node);
-            }
-        }
-        else if (flags & FlowFlags.Call) {
-            queue.add(flow.antecedent);
-            // Arguments can be narrowed using `FlowCall`s.
-            // See: node_modules/typescript/stable/src/compiler/checker.ts;l=28786-28810
-            interestingNodes.push(...flow.node.arguments);
-        }
-        else if (flags & FlowFlags.Condition) {
-            queue.add(flow.antecedent);
-            interestingNodes.push(flow.node);
-        }
-        else if (flags & FlowFlags.SwitchClause) {
-            queue.add(flow.antecedent);
-            // The switch expression can be narrowed, so it's an interesting node.
-            interestingNodes.push(flow.node.switchStatement.expression);
-        }
-        else if (flags & FlowFlags.Label) {
-            // simple label, a single ancestor.
-            if (flow.antecedent?.length === 1) {
-                queue.add(flow.antecedent[0]);
-                continue;
-            }
-            if (flags & FlowFlags.BranchLabel) {
-                // Normal branches. e.g. switch.
-                for (const f of flow.antecedent ?? []) {
-                    queue.add(f);
-                }
-            }
-            else {
-                // Branch for loops.
-                // The first antecedent always points to the flow node before the loop
-                // was entered. All other narrowing expressions, if present, are direct
-                // antecedents of the starting flow node, so we only need to look at the first.
-                // See: node_modules/typescript/stable/src/compiler/checker.ts;l=28108-28109
-                queue.add(flow.antecedent[0]);
-            }
-        }
-        else if (flags & FlowFlags.ArrayMutation) {
-            queue.add(flow.antecedent);
-            // Array mutations are never interesting for inputs, as we cannot migrate
-            // assignments to inputs.
-        }
-        else if (flags & FlowFlags.ReduceLabel) {
-            // reduce label is a try/catch re-routing.
-            // visit all possible branches.
-            // TODO: explore this more.
-            // See: node_modules/typescript/stable/src/compiler/binder.ts;l=1636-1649.
-            queue.add(flow.antecedent);
-            for (const f of flow.node.antecedents) {
-                queue.add(f);
-            }
-        }
-        else if (flags & FlowFlags.Start) {
-            // Note: TS itself only ever continues with parent control flows, if the pre-determined `flowContainer`
-            // of the referenced is different. E.g. narrowing might decide to choose a higher flow container if we
-            // reference a constant. In which case, TS allows escaping the flow container for narrowing. See:
-            // http://google3/third_party/javascript/node_modules/typescript/stable/src/compiler/checker.ts;l=29399-29414;rcl=623599846.
-            // and TypeScript's `narrowedConstInMethod` baseline test.
-            // --> We don't need this as an input cannot be a constant!
-            return interestingNodes;
-        }
-        else {
-            break;
-        }
-    }
-    return null;
-}
-/** Gets the flow node for the given node. */
-function getFlowNode(node) {
-    return node.flowNode ?? null;
-}
-
-/**
- * Analyzes the control flow of a list of references and returns
- * information about which nodes can be shared via a temporary variable
- * to enable narrowing.
- *
- * E.g. consider the following snippet:
- *
- * ```
- * someMethod() {
- *   if (this.bla) {
- *     this.bla.charAt(0);
- *   }
- * }
- * ```
- *
- * The analysis would inform the caller that `this.bla.charAt` can
- * be shared with the `this.bla` of the `if` condition.
- *
- * This is useful for the signal migration as it allows us to efficiently,
- * and minimally transform references into shared variables where needed.
- * Needed because signals are not narrowable by default, as they are functions.
- */
-function analyzeControlFlow(entries, checker) {
-    const result = [];
-    const referenceToMetadata = new Map();
-    // Prepare easy lookups for reference nodes to flow info.
-    for (const [idx, entry] of entries.entries()) {
-        referenceToMetadata.set(entry, {
-            flowContainer: getControlFlowContainer(entry),
-            resultIndex: idx,
-        });
-    }
-    for (const entry of entries) {
-        const { flowContainer, resultIndex } = referenceToMetadata.get(entry);
-        const flowPathInterestingNodes = traverseFlowForInterestingNodes(getFlowNode(entry));
-        assert__default["default"](flowContainer !== null && flowPathInterestingNodes !== null, 'Expected a flow container to exist.');
-        const narrowPartners = getAllMatchingReferencesInFlowPath(flowPathInterestingNodes, entry, referenceToMetadata, flowContainer, checker);
-        result.push({
-            id: resultIndex,
-            originalNode: entry,
-            flowContainer,
-            recommendedNode: 'preserve',
-        });
-        if (narrowPartners.length !== 0) {
-            connectSharedReferences(result, narrowPartners, resultIndex);
-        }
-    }
-    return result;
-}
-/**
- * Iterates through all partner flow nodes and connects them so that
- * the first node will act as the share partner, while all subsequent
- * nodes will point to the share node.
- */
-function connectSharedReferences(result, flowPartners, refId) {
-    const refFlowContainer = result[refId].flowContainer;
-    // Inside the list of flow partners (i.e. references to the same target),
-    // find the node that is the first one in the flow container (via its start pos).
-    let earliestPartner = null;
-    let earliestPartnerId = null;
-    for (const partnerId of flowPartners) {
-        if (earliestPartner === null ||
-            result[partnerId].originalNode.getStart() < earliestPartner.getStart()) {
-            earliestPartner = result[partnerId].originalNode;
-            earliestPartnerId = partnerId;
-        }
-    }
-    assert__default["default"](earliestPartner !== null, 'Expected an earliest partner to be found.');
-    assert__default["default"](earliestPartnerId !== null, 'Expected an earliest partner to be found.');
-    // Then, incorporate all similar references (or flow nodes) in between
-    // the reference and the earliest partner. References in between can also
-    // use the shared flow node and not preserve their original reference— as
-    // this would be rather unreadable and inefficient.
-    let highestBlock = null;
-    for (let i = earliestPartnerId; i <= refId; i++) {
-        // Different flow container captured sequentially in result. Ignore.
-        if (result[i].flowContainer !== refFlowContainer) {
-            continue;
-        }
-        // Iterate up the block, find the highest block within the flow container.
-        let block = result[i].originalNode.parent;
-        while (!isBlockLikeAncestor(block)) {
-            block = block.parent;
-        }
-        if (highestBlock === null || block.getStart() < highestBlock.getStart()) {
-            highestBlock = block;
-        }
-        if (i !== earliestPartnerId) {
-            result[i].recommendedNode = earliestPartnerId;
-        }
-    }
-    assert__default["default"](highestBlock, 'Expected a block anchor to be found');
-    result[earliestPartnerId].recommendedNode = highestBlock;
-}
-function isBlockLikeAncestor(node) {
-    // Note: Arrow functions may not have a block, but instead use an expression
-    // directly. This still signifies a "block" as we can convert the concise body
-    // to a block.
-    return ts__default["default"].isSourceFile(node) || ts__default["default"].isBlock(node) || ts__default["default"].isArrowFunction(node);
-}
-/**
- * Looks through the flow path and interesting nodes to determine which
- * of the potential "interesting" nodes point to the same reference.
- *
- * These nodes are then considered "partners" and will be returned via
- * their IDs (or practically their result indices).
- */
-function getAllMatchingReferencesInFlowPath(flowPathInterestingNodes, reference, referenceToMetadata, restrainingFlowContainer, checker) {
-    const partners = [];
-    for (const flowNode of flowPathInterestingNodes) {
-        // quick naive perf-optimized check to see if the flow node has a potential
-        // similar reference.
-        if (!flowNode.getText().includes(reference.getText())) {
-            continue;
-        }
-        const similarRefNodeId = findSimilarReferenceNode(flowNode, reference, referenceToMetadata, restrainingFlowContainer, checker);
-        if (similarRefNodeId !== null) {
-            partners.push(similarRefNodeId);
-        }
-    }
-    return partners;
-}
-/**
- * Checks if the given node contains an identifier that
- * matches the given reference. If so, returns its flow ID.
- */
-function findSimilarReferenceNode(start, reference, referenceToMetadata, restrainingFlowContainer, checker) {
-    return (ts__default["default"].forEachChild(start, function visitChild(node) {
-        // do not descend into control flow boundaries.
-        // only references sharing the same container are relevant.
-        // This is a performance optimization.
-        if (isControlFlowBoundary(node)) {
-            return;
-        }
-        // If this is not a potential matching identifier, check its children.
-        if (!ts__default["default"].isIdentifier(node) ||
-            referenceToMetadata.get(node)?.flowContainer !== restrainingFlowContainer) {
-            return ts__default["default"].forEachChild(node, visitChild);
-        }
-        // If this refers to a different instantiation of the input reference,
-        // continue looking.
-        if (!isLexicalSameReference(checker, node, reference)) {
-            return;
-        }
-        return { idx: referenceToMetadata.get(node).resultIndex };
-    })?.idx ?? null);
-}
-/**
- * Checks whether a given identifier is lexically equivalent.
- * e.g. checks that they have similar property receiver accesses.
- */
-function isLexicalSameReference(checker, sharePartner, reference) {
-    const aParent = unwrapParent(reference.parent);
-    // If the reference is not part a property access, return true. The references
-    // are guaranteed symbol matches.
-    if (!ts__default["default"].isPropertyAccessExpression(aParent) && !ts__default["default"].isElementAccessExpression(aParent)) {
-        return sharePartner.text === reference.text;
-    }
-    // If reference parent is part of a property expression, but the share
-    // partner not, then this cannot be shared.
-    const bParent = unwrapParent(sharePartner.parent);
-    if (aParent.kind !== bParent.kind) {
-        return false;
-    }
-    const aParentExprSymbol = checker.getSymbolAtLocation(aParent.expression);
-    const bParentExprSymbol = checker.getSymbolAtLocation(bParent.expression);
-    return aParentExprSymbol === bParentExprSymbol;
-}
-
-function migrateStandardTsReference(tsReferencesWithNarrowing, checker, info, replacements) {
-    const nameGenerator = new UniqueNamesGenerator(['Value', 'Val', 'Input']);
-    // TODO: Consider checking/properly handling optional chaining and narrowing.
-    for (const reference of tsReferencesWithNarrowing.values()) {
-        const controlFlowResult = analyzeControlFlow(reference.accesses, checker);
-        const idToSharedField = new Map();
-        for (const { id, originalNode, recommendedNode } of controlFlowResult) {
-            const sf = originalNode.getSourceFile();
-            // Original node is preserved. No narrowing, and hence not shared.
-            // Unwrap the signal directly.
-            if (recommendedNode === 'preserve') {
-                // Append `()` to unwrap the signal.
-                replacements.push(new Replacement(projectFile(sf, info), new TextUpdate({
-                    position: originalNode.getEnd(),
-                    end: originalNode.getEnd(),
-                    toInsert: '()',
-                })));
-                continue;
-            }
-            // This reference is shared with a previous reference. Replace the access
-            // with the temporary variable.
-            if (typeof recommendedNode === 'number') {
-                const replaceNode = traverseAccess(originalNode);
-                replacements.push(new Replacement(projectFile(sf, info), new TextUpdate({
-                    position: replaceNode.getStart(),
-                    end: replaceNode.getEnd(),
-                    // Extract the shared field name.
-                    toInsert: idToSharedField.get(recommendedNode),
-                })));
-                continue;
-            }
-            // Otherwise, we are creating a "shared reference" at the given node and
-            // block.
-            // Iterate up the original node, until we hit the "recommended block" level.
-            // We then use the previous child as anchor for inserting. This allows us
-            // to insert right before the first reference in the container, at the proper
-            // block level— instead of always inserting at the beginning of the container.
-            let parent = originalNode.parent;
-            let referenceNodeInBlock = originalNode;
-            while (parent !== recommendedNode) {
-                referenceNodeInBlock = parent;
-                parent = parent.parent;
-            }
-            const replaceNode = traverseAccess(originalNode);
-            const fieldName = nameGenerator.generate(originalNode.text, referenceNodeInBlock);
-            const filePath = projectFile(sf, info);
-            const temporaryVariableStr = `const ${fieldName} = ${replaceNode.getText()}();`;
-            idToSharedField.set(id, fieldName);
-            // If the common ancestor block of all shared references is an arrow function
-            // without a block, convert the arrow function to a block and insert the temporary
-            // variable at the beginning.
-            if (ts__default["default"].isArrowFunction(parent) && !ts__default["default"].isBlock(parent.body)) {
-                replacements.push(...createNewBlockToInsertVariable(parent, filePath, temporaryVariableStr));
-            }
-            else {
-                const leadingSpace = ts__default["default"].getLineAndCharacterOfPosition(sf, referenceNodeInBlock.getStart());
-                replacements.push(new Replacement(filePath, new TextUpdate({
-                    position: referenceNodeInBlock.getStart(),
-                    end: referenceNodeInBlock.getStart(),
-                    toInsert: `${temporaryVariableStr}\n${' '.repeat(leadingSpace.character)}`,
-                })));
-            }
-            replacements.push(new Replacement(projectFile(sf, info), new TextUpdate({
-                position: replaceNode.getStart(),
-                end: replaceNode.getEnd(),
-                toInsert: fieldName,
-            })));
-        }
-    }
-}
-
-/**
- * Migrates TypeScript input references to be signal compatible.
- *
- * The phase takes care of control flow analysis and generates temporary variables
- * where needed to ensure narrowing continues to work. E.g.
- *
- * ```
- * someMethod() {
- *   if (this.input) {
- *     this.input.charAt(0);
- *   }
- * }
- * ```
- *
- * will be transformed into:
- *
- * ```
- * someMethod() {
- *   const input_1 = this.input();
- *   if (input_1) {
- *     input_1.charAt(0);
- *   }
- * }
- * ```
- */
-function migrateTypeScriptReferences(host, references, checker, info) {
-    const tsReferencesWithNarrowing = new Map();
-    const tsReferencesInBindingElements = new Set();
-    const seenIdentifiers = new WeakSet();
-    for (const reference of references) {
-        // This pass only deals with TS references.
-        if (!isTsReference(reference)) {
-            continue;
-        }
-        // Skip references to incompatible inputs.
-        if (!host.shouldMigrateReferencesToField(reference.target)) {
-            continue;
-        }
-        // Never attempt to migrate write references.
-        // Those usually invalidate the target input most of the time, but in
-        // best-effort mode they are not.
-        if (reference.from.isWrite) {
-            continue;
-        }
-        // Skip duplicate references. E.g. in batching.
-        if (seenIdentifiers.has(reference.from.node)) {
-            continue;
-        }
-        seenIdentifiers.add(reference.from.node);
-        const targetKey = reference.target.key;
-        if (reference.from.isPartOfElementBinding) {
-            tsReferencesInBindingElements.add(reference.from.node);
-        }
-        else {
-            if (!tsReferencesWithNarrowing.has(targetKey)) {
-                tsReferencesWithNarrowing.set(targetKey, { accesses: [] });
-            }
-            tsReferencesWithNarrowing.get(targetKey).accesses.push(reference.from.node);
-        }
-    }
-    migrateBindingElementInputReference(tsReferencesInBindingElements, info, host.replacements, host.printer);
-    migrateStandardTsReference(tsReferencesWithNarrowing, checker, info, host.replacements);
-}
-
-/**
- * Migrates TypeScript "ts.Type" references. E.g.
-
- *  - `Partial<MyComp>` will be converted to `UnwrapSignalInputs<Partial<MyComp>>`.
-      in Catalyst test files.
- */
-function migrateTypeScriptTypeReferences(host, references, importManager, info) {
-    const seenTypeNodes = new WeakSet();
-    for (const reference of references) {
-        // This pass only deals with TS input class type references.
-        if (!isTsClassTypeReference(reference)) {
-            continue;
-        }
-        // Skip references to classes that are not fully migrated.
-        if (!host.shouldMigrateReferencesToClass(reference.target)) {
-            continue;
-        }
-        // Skip duplicate references. E.g. in batching.
-        if (seenTypeNodes.has(reference.from.node)) {
-            continue;
-        }
-        seenTypeNodes.add(reference.from.node);
-        if (reference.isPartialReference && reference.isPartOfCatalystFile) {
-            assert__default["default"](reference.from.node.typeArguments, 'Expected type arguments for partial reference.');
-            assert__default["default"](reference.from.node.typeArguments.length === 1, 'Expected an argument for reference.');
-            const firstArg = reference.from.node.typeArguments[0];
-            const sf = firstArg.getSourceFile();
-            // Naive detection of the import. Sufficient for this test file migration.
-            const catalystImport = sf.text.includes('google3/javascript/angular2/testing/catalyst/fake_async')
-                ? 'google3/javascript/angular2/testing/catalyst/fake_async'
-                : 'google3/javascript/angular2/testing/catalyst/async';
-            const unwrapImportExpr = importManager.addImport({
-                exportModuleSpecifier: catalystImport,
-                exportSymbolName: 'UnwrapSignalInputs',
-                requestedFile: sf,
-            });
-            host.replacements.push(new Replacement(projectFile(sf, info), new TextUpdate({
-                position: firstArg.getStart(),
-                end: firstArg.getStart(),
-                toInsert: `${host.printer.printNode(ts__default["default"].EmitHint.Unspecified, unwrapImportExpr, sf)}<`,
-            })));
-            host.replacements.push(new Replacement(projectFile(sf, info), new TextUpdate({ position: firstArg.getEnd(), end: firstArg.getEnd(), toInsert: '>' })));
-        }
-    }
-}
-
-/**
- * Angular compiler file system implementation that leverages an
- * CLI schematic virtual file tree.
- */
-class DevkitMigrationFilesystem {
-    constructor(tree) {
-        this.tree = tree;
-    }
-    extname(path) {
-        return core.extname(path);
-    }
-    isRoot(path) {
-        return path === core.normalize('/');
-    }
-    isRooted(path) {
-        return this.normalize(path).startsWith('/');
-    }
-    dirname(file) {
-        return this.normalize(core.dirname(file));
-    }
-    join(basePath, ...paths) {
-        return this.normalize(core.join(basePath, ...paths));
-    }
-    relative(from, to) {
-        return this.normalize(core.relative(from, to));
-    }
-    basename(filePath, extension) {
-        return posixPath__namespace.basename(filePath, extension);
-    }
-    normalize(path) {
-        return core.normalize(path);
-    }
-    resolve(...paths) {
-        const normalizedPaths = paths.map((p) => core.normalize(p));
-        // In dev-kit, the NodeJS working directory should never be
-        // considered, so `/` is the last resort over `cwd`.
-        return this.normalize(posixPath__namespace.resolve(core.normalize('/'), ...normalizedPaths));
-    }
-    pwd() {
-        return '/';
-    }
-    isCaseSensitive() {
-        return true;
-    }
-    exists(path) {
-        return statPath(this.tree, path) !== null;
-    }
-    readFile(path) {
-        return this.tree.readText(path);
-    }
-    readFileBuffer(path) {
-        const buffer = this.tree.read(path);
-        if (buffer === null) {
-            throw new Error(`File does not exist: ${path}`);
-        }
-        return buffer;
-    }
-    readdir(path) {
-        const dir = this.tree.getDir(path);
-        return [
-            ...dir.subdirs,
-            ...dir.subfiles,
-        ];
-    }
-    lstat(path) {
-        const stat = statPath(this.tree, path);
-        if (stat === null) {
-            throw new Error(`File does not exist for "lstat": ${path}`);
-        }
-        return stat;
-    }
-    stat(path) {
-        const stat = statPath(this.tree, path);
-        if (stat === null) {
-            throw new Error(`File does not exist for "stat": ${path}`);
-        }
-        return stat;
-    }
-    realpath(filePath) {
-        return filePath;
-    }
-    getDefaultLibLocation() {
-        return 'node_modules/typescript/lib';
-    }
-    ensureDir(path) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#ensureDir is not supported.');
-    }
-    writeFile(path, data) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#writeFile is not supported.');
-    }
-    removeFile(path) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#removeFile is not supported.');
-    }
-    copyFile(from, to) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#copyFile is not supported.');
-    }
-    moveFile(from, to) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#moveFile is not supported.');
-    }
-    removeDeep(path) {
-        // Migrations should compute replacements and not write directly.
-        throw new Error('DevkitFilesystem#removeDeep is not supported.');
-    }
-    chdir(_path) {
-        throw new Error('FileSystem#chdir is not supported.');
-    }
-    symlink() {
-        throw new Error('FileSystem#symlink is not supported.');
-    }
-}
-/** Stats the given path in the virtual tree. */
-function statPath(tree, path) {
-    let fileInfo = null;
-    let dirInfo = null;
-    try {
-        fileInfo = tree.get(path);
-    }
-    catch (e) {
-        if (e.constructor.name === 'PathIsDirectoryException') {
-            dirInfo = tree.getDir(path);
-        }
-        else {
-            throw e;
-        }
-    }
-    if (fileInfo !== null || dirInfo !== null) {
-        return {
-            isDirectory: () => dirInfo !== null,
-            isFile: () => fileInfo !== null,
-            isSymbolicLink: () => false,
-        };
-    }
-    return null;
-}
-
-/**
- * Groups the given replacements per project relative
- * file path.
- *
- * This allows for simple execution of the replacements
- * against a given file. E.g. via {@link applyTextUpdates}.
- */
-function groupReplacementsByFile(replacements) {
-    const result = new Map();
-    for (const { projectFile, update } of replacements) {
-        if (!result.has(projectFile.rootRelativePath)) {
-            result.set(projectFile.rootRelativePath, []);
-        }
-        result.get(projectFile.rootRelativePath).push(update);
-    }
-    return result;
-}
-
 exports.DevkitMigrationFilesystem = DevkitMigrationFilesystem;
-exports.GroupedTsAstVisitor = GroupedTsAstVisitor;
-exports.InheritanceGraph = InheritanceGraph;
 exports.Replacement = Replacement;
 exports.TextUpdate = TextUpdate;
 exports.TsurgeComplexMigration = TsurgeComplexMigration;
+exports.TsurgeFunnelMigration = TsurgeFunnelMigration;
 exports.applyImportManagerChanges = applyImportManagerChanges;
-exports.checkIncompatiblePatterns = checkIncompatiblePatterns;
-exports.checkInheritanceOfKnownFields = checkInheritanceOfKnownFields;
 exports.confirmAsSerializable = confirmAsSerializable;
 exports.createFindAllSourceFileReferencesVisitor = createFindAllSourceFileReferencesVisitor;
 exports.createNgtscProgram = createNgtscProgram;
-exports.cutStringToLineLimit = cutStringToLineLimit;
-exports.getMessageForClassIncompatibility = getMessageForClassIncompatibility;
-exports.getMessageForFieldIncompatibility = getMessageForFieldIncompatibility;
+exports.getBindingElementDeclaration = getBindingElementDeclaration;
+exports.getMemberName = getMemberName;
 exports.groupReplacementsByFile = groupReplacementsByFile;
-exports.insertPrecedingLine = insertPrecedingLine;
-exports.insertTodoForIncompatibility = insertTodoForIncompatibility;
-exports.isFieldIncompatibility = isFieldIncompatibility;
 exports.isHostBindingReference = isHostBindingReference;
 exports.isInputContainerNode = isInputContainerNode;
 exports.isTemplateReference = isTemplateReference;
+exports.isTsClassTypeReference = isTsClassTypeReference;
 exports.isTsReference = isTsReference;
-exports.migrateTypeScriptReferences = migrateTypeScriptReferences;
-exports.migrateTypeScriptTypeReferences = migrateTypeScriptTypeReferences;
-exports.nonIgnorableFieldIncompatibilities = nonIgnorableFieldIncompatibilities;
-exports.pickFieldIncompatibility = pickFieldIncompatibility;
 exports.projectFile = projectFile;
-exports.removeFromUnionIfPossible = removeFromUnionIfPossible;
 exports.traverseAccess = traverseAccess;
+exports.unwrapParent = unwrapParent;