@angular/core 20.0.0-next.0 → 20.0.0-next.2

package/schematics/bundles/signal-input-migration.js

@@ -1,37 +1,30 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.0
- * (c) 2010-2024 Google LLC. https://angular.io/
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var schematics = require('@angular-devkit/schematics');
-var migrate_ts_type_references = require('./migrate_ts_type_references-5089e4ef.js');
+var migrate_ts_type_references = require('./migrate_ts_type_references-DtkOnnv0.js');
 var ts = require('typescript');
 require('os');
-var checker = require('./checker-cf6f7980.js');
-var program = require('./program-362689f0.js');
+var checker = require('./checker-DF8ZaFW5.js');
+var program = require('./program-BZk27Ndu.js');
 require('path');
-var project_paths = require('./project_paths-7d2daa1e.js');
-var index = require('./index-42d84d69.js');
+var project_paths = require('./project_paths-Jtbi76Bs.js');
+var index = require('./index-DnkWgagp.js');
 var assert = require('assert');
-var apply_import_manager = require('./apply_import_manager-0959b78c.js');
-var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
-require('./leading_space-6e7a8ec6.js');
+var apply_import_manager = require('./apply_import_manager-CyRT0UvU.js');
+var project_tsconfig_paths = require('./project_tsconfig_paths-CDVxT6Ov.js');
+require('./leading_space-D9nQ8UQC.js');
 require('fs');
 require('module');
 require('url');
 require('@angular-devkit/core');
 require('node:path/posix');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
-
 /**
  * Class that holds information about a given directive and its input fields.
  */
@@ -102,7 +95,7 @@ class MigrationHost {
 
 function getInputDescriptor(hostOrInfo, node) {
     let className;
-    if (ts__default["default"].isAccessor(node)) {
+    if (ts.isAccessor(node)) {
         className = node.parent.name?.text || '<anonymous>';
     }
     else {
@@ -307,7 +300,7 @@ function prepareAnalysisInfo(userProgram, compiler, programAbsoluteRootPaths) {
  *    - imports that may need to be updated.
  */
 class MigrationResult {
-    printer = ts__default["default"].createPrinter({ newLine: ts__default["default"].NewLineKind.LineFeed });
+    printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
     // May be `null` if the input cannot be converted. This is also
     // signified by an incompatibility- but the input is tracked here as it
     // still is a "source input".
@@ -329,14 +322,14 @@ function extractDecoratorInput(node, host, reflector, metadataReader, evaluator)
  */
 function extractDtsInput(node, metadataReader) {
     if (!index.isInputContainerNode(node) ||
-        !ts__default["default"].isIdentifier(node.name) ||
+        !ts.isIdentifier(node.name) ||
         !node.getSourceFile().isDeclarationFile) {
         return null;
     }
     // If the potential node is not part of a valid input class, skip.
-    if (!ts__default["default"].isClassDeclaration(node.parent) ||
+    if (!ts.isClassDeclaration(node.parent) ||
         node.parent.name === undefined ||
-        !ts__default["default"].isIdentifier(node.parent.name)) {
+        !ts.isIdentifier(node.parent.name)) {
         return null;
     }
     let directiveMetadata = null;
@@ -372,7 +365,7 @@ function extractDtsInput(node, metadataReader) {
  */
 function extractSourceCodeInput(node, host, reflector, evaluator) {
     if (!index.isInputContainerNode(node) ||
-        !ts__default["default"].isIdentifier(node.name) ||
+        !ts.isIdentifier(node.name) ||
         node.getSourceFile().isDeclarationFile) {
         return null;
     }
@@ -440,7 +433,7 @@ function parseTransformOfInput(evaluatedInputOpts, node, reflector) {
         },
     ]);
     try {
-        return program.parseDecoratorInputTransformFunction(node.parent, node.name.text, transformValue, reflector, noopRefEmitter, checker.CompilationMode.FULL);
+        return checker.parseDecoratorInputTransformFunction(node.parent, node.name.text, transformValue, reflector, noopRefEmitter, checker.CompilationMode.FULL);
     }
     catch (e) {
         if (!(e instanceof checker.FatalDiagnosticError)) {
@@ -464,16 +457,16 @@ function parseTransformOfInput(evaluatedInputOpts, node, reflector) {
  */
 function prepareAndCheckForConversion(node, metadata, checker, options) {
     // Accessor inputs cannot be migrated right now.
-    if (ts__default["default"].isAccessor(node)) {
+    if (ts.isAccessor(node)) {
         return {
             context: node,
             reason: migrate_ts_type_references.FieldIncompatibilityReason.Accessor,
         };
     }
-    assert__default["default"](metadata.inputDecorator !== null, 'Expected an input decorator for inputs that are being migrated.');
+    assert(metadata.inputDecorator !== null, 'Expected an input decorator for inputs that are being migrated.');
     let initialValue = node.initializer;
     let isUndefinedInitialValue = node.initializer === undefined ||
-        (ts__default["default"].isIdentifier(node.initializer) && node.initializer.text === 'undefined');
+        (ts.isIdentifier(node.initializer) && node.initializer.text === 'undefined');
     const strictNullChecksEnabled = options.strict === true || options.strictNullChecks === true;
     const strictPropertyInitialization = options.strict === true || options.strictPropertyInitialization === true;
     // Shorthand should never be used, as would expand the type of `T` to be `T|undefined`.
@@ -515,9 +508,9 @@ function prepareAndCheckForConversion(node, metadata, checker, options) {
             };
         }
         if (!checker.isTypeAssignableTo(checker.getUndefinedType(), checker.getTypeFromTypeNode(typeToAdd))) {
-            typeToAdd = ts__default["default"].factory.createUnionTypeNode([
+            typeToAdd = ts.factory.createUnionTypeNode([
                 typeToAdd,
-                ts__default["default"].factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.UndefinedKeyword),
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
             ]);
         }
     }
@@ -538,7 +531,7 @@ function prepareAndCheckForConversion(node, metadata, checker, options) {
             'Input is initialized to `undefined` but type does not allow this value. ' +
                 'This worked with `@Input` because your project uses `--strictPropertyInitialization=false`.';
         isUndefinedInitialValue = false;
-        initialValue = ts__default["default"].factory.createNonNullExpression(ts__default["default"].factory.createIdentifier('undefined'));
+        initialValue = ts.factory.createNonNullExpression(ts.factory.createIdentifier('undefined'));
     }
     // Attempt to extract type from input initial value. No explicit type, but input is required.
     // Hence we need an explicit type, or fall back to `typeof`.
@@ -572,28 +565,28 @@ function inferImportableTypeForInput(checker, node, initialValue) {
     // return a type node fully derived from the resolved type.
     if (isPrimitiveImportableTypeNode(propertyType) ||
         (propertyType.isUnion() && propertyType.types.every(isPrimitiveImportableTypeNode))) {
-        return checker.typeToTypeNode(propertyType, node, ts__default["default"].NodeBuilderFlags.NoTypeReduction) ?? null;
+        return checker.typeToTypeNode(propertyType, node, ts.NodeBuilderFlags.NoTypeReduction) ?? null;
     }
     // Alternatively, try to infer a simple importable type from\
     // the initializer.
-    if (ts__default["default"].isIdentifier(initialValue)) {
+    if (ts.isIdentifier(initialValue)) {
         // @Input({required: true}) bla = SOME_DEFAULT;
-        return ts__default["default"].factory.createTypeQueryNode(initialValue);
+        return ts.factory.createTypeQueryNode(initialValue);
     }
-    else if (ts__default["default"].isPropertyAccessExpression(initialValue) &&
-        ts__default["default"].isIdentifier(initialValue.name) &&
-        ts__default["default"].isIdentifier(initialValue.expression)) {
+    else if (ts.isPropertyAccessExpression(initialValue) &&
+        ts.isIdentifier(initialValue.name) &&
+        ts.isIdentifier(initialValue.expression)) {
         // @Input({required: true}) bla = prop.SOME_DEFAULT;
-        return ts__default["default"].factory.createTypeQueryNode(ts__default["default"].factory.createQualifiedName(initialValue.name, initialValue.expression));
+        return ts.factory.createTypeQueryNode(ts.factory.createQualifiedName(initialValue.name, initialValue.expression));
     }
     return null;
 }
 function isPrimitiveImportableTypeNode(type) {
-    return !!(type.flags & ts__default["default"].TypeFlags.BooleanLike ||
-        type.flags & ts__default["default"].TypeFlags.StringLike ||
-        type.flags & ts__default["default"].TypeFlags.NumberLike ||
-        type.flags & ts__default["default"].TypeFlags.Undefined ||
-        type.flags & ts__default["default"].TypeFlags.Null);
+    return !!(type.flags & ts.TypeFlags.BooleanLike ||
+        type.flags & ts.TypeFlags.StringLike ||
+        type.flags & ts.TypeFlags.NumberLike ||
+        type.flags & ts.TypeFlags.Undefined ||
+        type.flags & ts.TypeFlags.Null);
 }
 
 /**
@@ -604,7 +597,7 @@ function pass1__IdentifySourceFileAndDeclarationInputs(sf, host, checker, reflec
     const visitor = (node) => {
         const decoratorInput = extractDecoratorInput(node, host, reflector, dtsMetadataReader, evaluator);
         if (decoratorInput !== null) {
-            assert__default["default"](index.isInputContainerNode(node), 'Expected input to be declared on accessor or property.');
+            assert(index.isInputContainerNode(node), 'Expected input to be declared on accessor or property.');
             const inputDescr = getInputDescriptor(host, node);
             // track all inputs, even from declarations for reference resolution.
             knownDecoratorInputs.register({ descriptor: inputDescr, metadata: decoratorInput, node });
@@ -623,10 +616,10 @@ function pass1__IdentifySourceFileAndDeclarationInputs(sf, host, checker, reflec
         }
         // track all imports to `Input` or `input`.
         let importName = null;
-        if (ts__default["default"].isImportSpecifier(node) &&
+        if (ts.isImportSpecifier(node) &&
             ((importName = (node.propertyName ?? node.name).text) === 'Input' ||
                 importName === 'input') &&
-            ts__default["default"].isStringLiteral(node.parent.parent.parent.moduleSpecifier) &&
+            ts.isStringLiteral(node.parent.parent.parent.moduleSpecifier) &&
             (host.isMigratingCore || node.parent.parent.parent.moduleSpecifier.text === '@angular/core')) {
             if (!result.inputDecoratorSpecifiers.has(sf)) {
                 result.inputDecoratorSpecifiers.set(sf, []);
@@ -636,9 +629,9 @@ function pass1__IdentifySourceFileAndDeclarationInputs(sf, host, checker, reflec
                 node,
             });
         }
-        ts__default["default"].forEachChild(node, visitor);
+        ts.forEachChild(node, visitor);
     };
-    ts__default["default"].forEachChild(sf, visitor);
+    ts.forEachChild(sf, visitor);
 }
 
 /**
@@ -767,7 +760,7 @@ function pass4__checkInheritanceOfInputs(inheritanceGraph, metaRegistry, knownIn
         isClassWithKnownFields: (clazz) => knownInputs.isInputContainingClass(clazz),
         getFieldsForClass: (clazz) => {
             const directiveInfo = knownInputs.getDirectiveInfoForClass(clazz);
-            assert__default["default"](directiveInfo !== undefined, 'Expected directive info to exist for input.');
+            assert(directiveInfo !== undefined, 'Expected directive info to exist for input.');
             return Array.from(directiveInfo.inputFields.values()).map((i) => i.descriptor);
         },
     });
@@ -974,7 +967,7 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
     if (metadata.bindingPropertyName !== metadata.classPropertyName || metadata.transform !== null) {
         const properties = [];
         if (metadata.bindingPropertyName !== metadata.classPropertyName) {
-            properties.push(ts__default["default"].factory.createPropertyAssignment('alias', ts__default["default"].factory.createStringLiteral(metadata.bindingPropertyName)));
+            properties.push(ts.factory.createPropertyAssignment('alias', ts.factory.createStringLiteral(metadata.bindingPropertyName)));
         }
         if (metadata.transform !== null) {
             const transformRes = extractTransformOfInput(metadata.transform, resolvedType, checker);
@@ -985,7 +978,7 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
                     (leadingTodoText ? `${leadingTodoText} ` : '') + transformRes.leadingTodoText;
             }
         }
-        optionsLiteral = ts__default["default"].factory.createObjectLiteralExpression(properties);
+        optionsLiteral = ts.factory.createObjectLiteralExpression(properties);
     }
     // The initial value is `undefined` or none is present:
     //    - We may be able to use the `input()` shorthand
@@ -993,14 +986,14 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
     if (initialValue === undefined) {
         // Shorthand not possible, so explicitly add `undefined`.
         if (preferShorthandIfPossible === null) {
-            initialValue = ts__default["default"].factory.createIdentifier('undefined');
+            initialValue = ts.factory.createIdentifier('undefined');
         }
         else {
             resolvedType = preferShorthandIfPossible.originalType;
             // When using the `input()` shorthand, try cutting of `undefined` from potential
             // union types. `undefined` will be automatically included in the type.
-            if (ts__default["default"].isUnionTypeNode(resolvedType)) {
-                resolvedType = migrate_ts_type_references.removeFromUnionIfPossible(resolvedType, (t) => t.kind !== ts__default["default"].SyntaxKind.UndefinedKeyword);
+            if (ts.isUnionTypeNode(resolvedType)) {
+                resolvedType = migrate_ts_type_references.removeFromUnionIfPossible(resolvedType, (t) => t.kind !== ts.SyntaxKind.UndefinedKeyword);
             }
         }
     }
@@ -1011,13 +1004,13 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
         if (metadata.transform !== null) {
             // Note: The TCB code generation may use the same type node and attach
             // synthetic comments for error reporting. We remove those explicitly here.
-            typeArguments.push(ts__default["default"].setSyntheticTrailingComments(metadata.transform.type.node, undefined));
+            typeArguments.push(ts.setSyntheticTrailingComments(metadata.transform.type.node, undefined));
         }
     }
     // Always add an initial value when the input is optional, and we have one, or we need one
     // to be able to pass options as the second argument.
     if (!metadata.required && (initialValue !== undefined || optionsLiteral !== null)) {
-        inputArgs.push(initialValue ?? ts__default["default"].factory.createIdentifier('undefined'));
+        inputArgs.push(initialValue ?? ts.factory.createIdentifier('undefined'));
     }
     if (optionsLiteral !== null) {
         inputArgs.push(optionsLiteral);
@@ -1028,16 +1021,16 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
         requestedFile: node.getSourceFile(),
     });
     const inputInitializerFn = metadata.required
-        ? ts__default["default"].factory.createPropertyAccessExpression(inputFnRef, 'required')
+        ? ts.factory.createPropertyAccessExpression(inputFnRef, 'required')
         : inputFnRef;
-    const inputInitializer = ts__default["default"].factory.createCallExpression(inputInitializerFn, typeArguments, inputArgs);
+    const inputInitializer = ts.factory.createCallExpression(inputInitializerFn, typeArguments, inputArgs);
     let modifiersWithoutInputDecorator = node.modifiers?.filter((m) => m !== originalInputDecorator.node) ?? [];
     // Add `readonly` to all new signal input declarations.
-    if (!modifiersWithoutInputDecorator?.some((s) => s.kind === ts__default["default"].SyntaxKind.ReadonlyKeyword)) {
-        modifiersWithoutInputDecorator.push(ts__default["default"].factory.createModifier(ts__default["default"].SyntaxKind.ReadonlyKeyword));
+    if (!modifiersWithoutInputDecorator?.some((s) => s.kind === ts.SyntaxKind.ReadonlyKeyword)) {
+        modifiersWithoutInputDecorator.push(ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword));
     }
-    const newNode = ts__default["default"].factory.createPropertyDeclaration(modifiersWithoutInputDecorator, node.name, undefined, undefined, inputInitializer);
-    const newPropertyText = result.printer.printNode(ts__default["default"].EmitHint.Unspecified, newNode, node.getSourceFile());
+    const newNode = ts.factory.createPropertyDeclaration(modifiersWithoutInputDecorator, node.name, undefined, undefined, inputInitializer);
+    const newPropertyText = result.printer.printNode(ts.EmitHint.Unspecified, newNode, node.getSourceFile());
     const replacements = [];
     if (leadingTodoText !== null) {
         replacements.push(migrate_ts_type_references.insertPrecedingLine(node, info, '// TODO: Notes from signal input migration:'), ...migrate_ts_type_references.cutStringToLineLimit(leadingTodoText, 70).map((line) => migrate_ts_type_references.insertPrecedingLine(node, info, `//  ${line}`)));
@@ -1054,29 +1047,29 @@ function convertToSignalInput(node, { resolvedMetadata: metadata, resolvedType,
  * that works for the new signal `input()` API.
  */
 function extractTransformOfInput(transform, resolvedType, checker) {
-    assert__default["default"](ts__default["default"].isExpression(transform.node), `Expected transform to be an expression.`);
+    assert(ts.isExpression(transform.node), `Expected transform to be an expression.`);
     let transformFn = transform.node;
     let leadingTodoText = null;
     // If there is an explicit type, check if the transform return type actually works.
     // In some cases, the transform function is not compatible because with decorator inputs,
     // those were not checked. We cast the transform to `any` and add a TODO.
     // TODO: Capture this in the design doc.
-    if (resolvedType !== undefined && !ts__default["default"].isSyntheticExpression(resolvedType)) {
+    if (resolvedType !== undefined && !ts.isSyntheticExpression(resolvedType)) {
         // Note: If the type is synthetic, we cannot check, and we accept that in the worst case
         // we will create code that is not necessarily compiling. This is unlikely, but notably
         // the errors would be correct and valuable.
         const transformType = checker.getTypeAtLocation(transform.node);
         const transformSignature = transformType.getCallSignatures()[0];
-        assert__default["default"](transformSignature !== undefined, 'Expected transform to be an invoke-able.');
+        assert(transformSignature !== undefined, 'Expected transform to be an invoke-able.');
         if (!checker.isTypeAssignableTo(checker.getReturnTypeOfSignature(transformSignature), checker.getTypeFromTypeNode(resolvedType))) {
             leadingTodoText =
                 'Input type is incompatible with transform. The migration added an `any` cast. ' +
                     'This worked previously because Angular was unable to check transforms.';
-            transformFn = ts__default["default"].factory.createAsExpression(ts__default["default"].factory.createParenthesizedExpression(transformFn), ts__default["default"].factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.AnyKeyword));
+            transformFn = ts.factory.createAsExpression(ts.factory.createParenthesizedExpression(transformFn), ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword));
         }
     }
     return {
-        node: ts__default["default"].factory.createPropertyAssignment('transform', transformFn),
+        node: ts.factory.createPropertyAssignment('transform', transformFn),
         leadingTodoText,
     };
 }
@@ -1104,8 +1097,8 @@ function pass6__migrateInputDeclarations(host, checker, result, knownInputs, imp
             filesWithIncompatibleInputs.add(sf);
             continue;
         }
-        assert__default["default"](metadata !== null, `Expected metadata to exist for input isn't marked incompatible.`);
-        assert__default["default"](!ts__default["default"].isAccessor(input.node), 'Accessor inputs are incompatible.');
+        assert(metadata !== null, `Expected metadata to exist for input isn't marked incompatible.`);
+        assert(!ts.isAccessor(input.node), 'Accessor inputs are incompatible.');
         filesWithMigratedInputs.add(sf);
         result.replacements.push(...convertToSignalInput(input.node, metadata, info, checker, importManager, result));
     }

package/schematics/bundles/signal-queries-migration.js

@@ -1,36 +1,29 @@
 'use strict';
 /**
- * @license Angular v20.0.0-next.0
- * (c) 2010-2024 Google LLC. https://angular.io/
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var schematics = require('@angular-devkit/schematics');
-var project_tsconfig_paths = require('./project_tsconfig_paths-6c9cde78.js');
-var project_paths = require('./project_paths-7d2daa1e.js');
+var project_tsconfig_paths = require('./project_tsconfig_paths-CDVxT6Ov.js');
+var project_paths = require('./project_paths-Jtbi76Bs.js');
 require('os');
 var ts = require('typescript');
-var checker = require('./checker-cf6f7980.js');
-var program = require('./program-362689f0.js');
+var checker = require('./checker-DF8ZaFW5.js');
+var program = require('./program-BZk27Ndu.js');
 require('path');
-var apply_import_manager = require('./apply_import_manager-0959b78c.js');
-var migrate_ts_type_references = require('./migrate_ts_type_references-5089e4ef.js');
+var apply_import_manager = require('./apply_import_manager-CyRT0UvU.js');
+var migrate_ts_type_references = require('./migrate_ts_type_references-DtkOnnv0.js');
 var assert = require('assert');
-var index = require('./index-42d84d69.js');
+var index = require('./index-DnkWgagp.js');
 require('@angular-devkit/core');
 require('node:path/posix');
 require('fs');
 require('module');
 require('url');
-require('./leading_space-6e7a8ec6.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
-var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
+require('./leading_space-D9nQ8UQC.js');
 
 /**
  * Phase that migrates Angular host binding references to
@@ -106,14 +99,14 @@ function migrateTemplateReferences(host, references) {
  */
 function extractQueryListType(node) {
     // Initializer variant of `new QueryList<T>()`.
-    if (ts__default["default"].isNewExpression(node) &&
-        ts__default["default"].isIdentifier(node.expression) &&
+    if (ts.isNewExpression(node) &&
+        ts.isIdentifier(node.expression) &&
         node.expression.text === 'QueryList') {
         return node.typeArguments?.[0];
     }
     // Type variant of `: QueryList<T>`.
-    if (ts__default["default"].isTypeReferenceNode(node) &&
-        ts__default["default"].isIdentifier(node.typeName) &&
+    if (ts.isTypeReferenceNode(node) &&
+        ts.isIdentifier(node.typeName) &&
         node.typeName.text === 'QueryList') {
         return node.typeArguments?.[0];
     }
@@ -166,14 +159,14 @@ function computeReplacementsToMigrateQuery(node, metadata, importManager, info,
         }
     }
     if (metadata.queryInfo.read !== null) {
-        assert__default["default"](metadata.queryInfo.read instanceof checker.WrappedNodeExpr);
-        optionProperties.push(ts__default["default"].factory.createPropertyAssignment('read', metadata.queryInfo.read.node));
+        assert(metadata.queryInfo.read instanceof checker.WrappedNodeExpr);
+        optionProperties.push(ts.factory.createPropertyAssignment('read', metadata.queryInfo.read.node));
     }
     if (metadata.queryInfo.descendants !== defaultDescendants) {
-        optionProperties.push(ts__default["default"].factory.createPropertyAssignment('descendants', metadata.queryInfo.descendants ? ts__default["default"].factory.createTrue() : ts__default["default"].factory.createFalse()));
+        optionProperties.push(ts.factory.createPropertyAssignment('descendants', metadata.queryInfo.descendants ? ts.factory.createTrue() : ts.factory.createFalse()));
     }
     if (optionProperties.length > 0) {
-        args.push(ts__default["default"].factory.createObjectLiteralExpression(optionProperties));
+        args.push(ts.factory.createObjectLiteralExpression(optionProperties));
     }
     const strictNullChecksEnabled = options.strict === true || options.strictNullChecks === true;
     const strictPropertyInitialization = options.strict === true || options.strictPropertyInitialization === true;
@@ -196,12 +189,12 @@ function computeReplacementsToMigrateQuery(node, metadata, importManager, info,
     if (isRequired && metadata.queryInfo.first) {
         // If the query is required already via some indicators, and this is a "single"
         // query, use the available `.required` method.
-        newQueryFn = ts__default["default"].factory.createPropertyAccessExpression(newQueryFn, 'required');
+        newQueryFn = ts.factory.createPropertyAccessExpression(newQueryFn, 'required');
     }
     // If this query is still nullable (i.e. not required), attempt to remove
     // explicit `undefined` types if possible.
-    if (!isRequired && type !== undefined && ts__default["default"].isUnionTypeNode(type)) {
-        type = migrate_ts_type_references.removeFromUnionIfPossible(type, (v) => v.kind !== ts__default["default"].SyntaxKind.UndefinedKeyword);
+    if (!isRequired && type !== undefined && ts.isUnionTypeNode(type)) {
+        type = migrate_ts_type_references.removeFromUnionIfPossible(type, (v) => v.kind !== ts.SyntaxKind.UndefinedKeyword);
     }
     let locatorType = Array.isArray(metadata.queryInfo.predicate)
         ? null
@@ -211,23 +204,23 @@ function computeReplacementsToMigrateQuery(node, metadata, importManager, info,
     // on the TS inference, instead of repeating types, like in `viewChild<Button>(Button)`.
     if (type !== undefined &&
         resolvedReadType instanceof checker.WrappedNodeExpr &&
-        ts__default["default"].isIdentifier(resolvedReadType.node) &&
-        ts__default["default"].isTypeReferenceNode(type) &&
-        ts__default["default"].isIdentifier(type.typeName) &&
+        ts.isIdentifier(resolvedReadType.node) &&
+        ts.isTypeReferenceNode(type) &&
+        ts.isIdentifier(type.typeName) &&
         type.typeName.text === resolvedReadType.node.text) {
         locatorType = null;
     }
-    const call = ts__default["default"].factory.createCallExpression(newQueryFn, 
+    const call = ts.factory.createCallExpression(newQueryFn, 
     // If there is no resolved `ReadT` (e.g. string predicate), we use the
     // original type explicitly as generic. Otherwise, query API is smart
     // enough to always infer.
     resolvedReadType === null && type !== undefined ? [type] : undefined, args);
-    const updated = ts__default["default"].factory.createPropertyDeclaration([ts__default["default"].factory.createModifier(ts__default["default"].SyntaxKind.ReadonlyKeyword)], node.name, undefined, undefined, call);
+    const updated = ts.factory.createPropertyDeclaration([ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword)], node.name, undefined, undefined, call);
     return [
         new project_paths.Replacement(project_paths.projectFile(node.getSourceFile(), info), new project_paths.TextUpdate({
             position: node.getStart(),
             end: node.getEnd(),
-            toInsert: printer.printNode(ts__default["default"].EmitHint.Unspecified, updated, sf),
+            toInsert: printer.printNode(ts.EmitHint.Unspecified, updated, sf),
         })),
     ];
 }
@@ -238,7 +231,7 @@ function computeReplacementsToMigrateQuery(node, metadata, importManager, info,
  */
 function getClassFieldDescriptorForSymbol(symbol, info) {
     if (symbol?.valueDeclaration === undefined ||
-        !ts__default["default"].isPropertyDeclaration(symbol.valueDeclaration)) {
+        !ts.isPropertyDeclaration(symbol.valueDeclaration)) {
         return null;
     }
     const key = getUniqueIDForClassProperty(symbol.valueDeclaration, info);
@@ -259,7 +252,7 @@ function getClassFieldDescriptorForSymbol(symbol, info) {
  * would then match identity.
  */
 function getUniqueIDForClassProperty(property, info) {
-    if (!ts__default["default"].isClassDeclaration(property.parent) || property.parent.name === undefined) {
+    if (!ts.isClassDeclaration(property.parent) || property.parent.name === undefined) {
         return null;
     }
     if (property.name === undefined) {
@@ -279,14 +272,14 @@ function getUniqueIDForClassProperty(property, info) {
  * returns its resolved metadata if possible.
  */
 function extractSourceQueryDefinition(node, reflector, evaluator, info) {
-    if ((!ts__default["default"].isPropertyDeclaration(node) && !ts__default["default"].isAccessor(node)) ||
-        !ts__default["default"].isClassDeclaration(node.parent) ||
+    if ((!ts.isPropertyDeclaration(node) && !ts.isAccessor(node)) ||
+        !ts.isClassDeclaration(node.parent) ||
         node.parent.name === undefined ||
-        !ts__default["default"].isIdentifier(node.name)) {
+        !ts.isIdentifier(node.name)) {
         return null;
     }
     const decorators = reflector.getDecoratorsOfDeclaration(node) ?? [];
-    const ngDecorators = checker.getAngularDecorators(decorators, program.queryDecoratorNames, /* isCore */ false);
+    const ngDecorators = checker.getAngularDecorators(decorators, checker.queryDecoratorNames, /* isCore */ false);
     if (ngDecorators.length === 0) {
         return null;
     }
@@ -313,7 +306,7 @@ function extractSourceQueryDefinition(node, reflector, evaluator, info) {
     }
     let queryInfo = null;
     try {
-        queryInfo = program.extractDecoratorQueryMetadata(node, decorator.name, decorator.args ?? [], node.name.text, reflector, evaluator);
+        queryInfo = checker.extractDecoratorQueryMetadata(node, decorator.name, decorator.args ?? [], node.name.text, reflector, evaluator);
     }
     catch (e) {
         if (!(e instanceof checker.FatalDiagnosticError)) {
@@ -412,7 +405,7 @@ class KnownQueries {
         return this.classToQueryFields.get(clazz);
     }
     getAllClassesWithQueries() {
-        return Array.from(this.classToQueryFields.keys()).filter((c) => ts__default["default"].isClassDeclaration(c));
+        return Array.from(this.classToQueryFields.keys()).filter((c) => ts.isClassDeclaration(c));
     }
     captureKnownFieldInheritanceRelationship(derived, parent) {
         // Note: The edge problematic pattern recognition is not as good as the one
@@ -505,8 +498,8 @@ function queryFunctionNameToDecorator(name) {
 function checkTsReferenceAccessesField(ref, fieldName) {
     const accessNode = index.traverseAccess(ref.from.node);
     // Check if the reference is part of a property access.
-    if (!ts__default["default"].isPropertyAccessExpression(accessNode.parent) ||
-        !ts__default["default"].isIdentifier(accessNode.parent.name)) {
+    if (!ts.isPropertyAccessExpression(accessNode.parent) ||
+        !ts.isIdentifier(accessNode.parent.name)) {
         return null;
     }
     // Check if the reference is refers to the given field name.
@@ -543,7 +536,7 @@ function checkTsReferenceCallsField(ref, fieldName) {
     if (propertyAccess === null) {
         return null;
     }
-    if (ts__default["default"].isCallExpression(propertyAccess.parent) &&
+    if (ts.isCallExpression(propertyAccess.parent) &&
         propertyAccess.parent.expression === propertyAccess) {
         return propertyAccess.parent;
     }
@@ -769,17 +762,17 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
                     fieldName: extractedQuery.queryInfo.propertyName,
                     isMulti: extractedQuery.queryInfo.first === false,
                 };
-                if (ts__default["default"].isAccessor(queryNode)) {
+                if (ts.isAccessor(queryNode)) {
                     markFieldIncompatibleInMetadata(res.potentialProblematicQueries, extractedQuery.id, migrate_ts_type_references.FieldIncompatibilityReason.Accessor);
                 }
                 // Detect queries with union types that are uncommon to be
                 // automatically migrate-able. E.g. `refs: ElementRef|null`,
                 // or `ElementRef|SomeOtherType`.
                 if (queryNode.type !== undefined &&
-                    ts__default["default"].isUnionTypeNode(queryNode.type) &&
+                    ts.isUnionTypeNode(queryNode.type) &&
                     // Either too large union, or doesn't match `T|undefined`.
                     (queryNode.type.types.length > 2 ||
-                        !queryNode.type.types.some((t) => t.kind === ts__default["default"].SyntaxKind.UndefinedKeyword))) {
+                        !queryNode.type.types.some((t) => t.kind === ts.SyntaxKind.UndefinedKeyword))) {
                     markFieldIncompatibleInMetadata(res.potentialProblematicQueries, extractedQuery.id, migrate_ts_type_references.FieldIncompatibilityReason.SignalQueries__IncompatibleMultiUnionType);
                 }
                 // Migrating fields with `@HostBinding` is incompatible as
@@ -927,7 +920,7 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
         const evaluator = new program.PartialEvaluator(reflector, checker$1, null);
         const replacements = [];
         const importManager = new checker.ImportManager();
-        const printer = ts__default["default"].createPrinter();
+        const printer = ts.createPrinter();
         const filesWithSourceQueries = new Map();
         const filesWithIncompleteMigration = new Map();
         const filesWithQueryListOutsideOfDeclarations = new WeakSet();
@@ -944,8 +937,8 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
                 return;
             }
             // Detect OTHER queries, inside `.d.ts`. Needed for reference resolution below.
-            if (ts__default["default"].isPropertyDeclaration(node) ||
-                (ts__default["default"].isAccessor(node) && ts__default["default"].isClassDeclaration(node.parent))) {
+            if (ts.isPropertyDeclaration(node) ||
+                (ts.isAccessor(node) && ts.isClassDeclaration(node.parent))) {
                 const classFieldID = getUniqueIDForClassProperty(node, info);
                 if (classFieldID !== null && globalMetadata.knownQueryFields[classFieldID] !== undefined) {
                     knownQueries.registerQueryField(node, classFieldID);
@@ -954,15 +947,15 @@ class SignalQueriesMigration extends project_paths.TsurgeComplexMigration {
             }
             // Detect potential usages of `QueryList` outside of queries or imports.
             // Those prevent us from removing the import later.
-            if (ts__default["default"].isIdentifier(node) &&
+            if (ts.isIdentifier(node) &&
                 node.text === 'QueryList' &&
-                ts__default["default"].findAncestor(node, ts__default["default"].isImportDeclaration) === undefined) {
+                ts.findAncestor(node, ts.isImportDeclaration) === undefined) {
                 filesWithQueryListOutsideOfDeclarations.add(node.getSourceFile());
             }
-            ts__default["default"].forEachChild(node, queryWholeProgramVisitor);
+            ts.forEachChild(node, queryWholeProgramVisitor);
         };
         for (const sf of info.fullProgramSourceFiles) {
-            ts__default["default"].forEachChild(sf, queryWholeProgramVisitor);
+            ts.forEachChild(sf, queryWholeProgramVisitor);
         }
         // Set of all queries in the program. Useful for speeding up reference
         // lookups below.