@angular/core 21.0.0-next.8 → 21.0.0-rc.0

package/schematics/bundles/{migrate_ts_type_references-Cu-FR4L5.cjs → migrate_ts_type_references-UGIUl7En.cjs}

@@ -1,20 +1,18 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.8
+ * @license Angular v21.0.0-rc.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
-var project_tsconfig_paths = require('./project_tsconfig_paths-CdhVNYMk.cjs');
-var ts = require('typescript');
-require('os');
 var assert = require('assert');
-var index = require('./index-DWSaRJdz.cjs');
-var project_paths = require('./project_paths-C6g3lqjX.cjs');
+var ts = require('typescript');
+var migrations = require('@angular/compiler-cli/private/migrations');
+var index = require('./index-B7I9sIUx.cjs');
+var project_paths = require('./project_paths-DvD50ouC.cjs');
 var leading_space = require('./leading_space-D9nQ8UQC.cjs');
-require('./index-BnmACOsq.cjs');
-require('path');
+require('@angular/compiler-cli');
 require('node:path');
 
 /**
@@ -77,6 +75,441 @@ function pickFieldIncompatibility(a, b) {
     return a;
 }
 
+/**
+ * A lazily created TextEncoder instance for converting strings into UTF-8 bytes
+ */
+// Utils
+var Endian;
+(function (Endian) {
+    Endian[Endian["Little"] = 0] = "Little";
+    Endian[Endian["Big"] = 1] = "Big";
+})(Endian || (Endian = {}));
+
+//// Types
+var TypeModifier;
+(function (TypeModifier) {
+    TypeModifier[TypeModifier["None"] = 0] = "None";
+    TypeModifier[TypeModifier["Const"] = 1] = "Const";
+})(TypeModifier || (TypeModifier = {}));
+class Type {
+    modifiers;
+    constructor(modifiers = TypeModifier.None) {
+        this.modifiers = modifiers;
+    }
+    hasModifier(modifier) {
+        return (this.modifiers & modifier) !== 0;
+    }
+}
+var BuiltinTypeName;
+(function (BuiltinTypeName) {
+    BuiltinTypeName[BuiltinTypeName["Dynamic"] = 0] = "Dynamic";
+    BuiltinTypeName[BuiltinTypeName["Bool"] = 1] = "Bool";
+    BuiltinTypeName[BuiltinTypeName["String"] = 2] = "String";
+    BuiltinTypeName[BuiltinTypeName["Int"] = 3] = "Int";
+    BuiltinTypeName[BuiltinTypeName["Number"] = 4] = "Number";
+    BuiltinTypeName[BuiltinTypeName["Function"] = 5] = "Function";
+    BuiltinTypeName[BuiltinTypeName["Inferred"] = 6] = "Inferred";
+    BuiltinTypeName[BuiltinTypeName["None"] = 7] = "None";
+})(BuiltinTypeName || (BuiltinTypeName = {}));
+class BuiltinType extends Type {
+    name;
+    constructor(name, modifiers) {
+        super(modifiers);
+        this.name = name;
+    }
+    visitType(visitor, context) {
+        return visitor.visitBuiltinType(this, context);
+    }
+}
+new BuiltinType(BuiltinTypeName.Dynamic);
+const INFERRED_TYPE = new BuiltinType(BuiltinTypeName.Inferred);
+new BuiltinType(BuiltinTypeName.Bool);
+new BuiltinType(BuiltinTypeName.Int);
+new BuiltinType(BuiltinTypeName.Number);
+new BuiltinType(BuiltinTypeName.String);
+new BuiltinType(BuiltinTypeName.Function);
+new BuiltinType(BuiltinTypeName.None);
+///// Expressions
+var UnaryOperator;
+(function (UnaryOperator) {
+    UnaryOperator[UnaryOperator["Minus"] = 0] = "Minus";
+    UnaryOperator[UnaryOperator["Plus"] = 1] = "Plus";
+})(UnaryOperator || (UnaryOperator = {}));
+var BinaryOperator;
+(function (BinaryOperator) {
+    BinaryOperator[BinaryOperator["Equals"] = 0] = "Equals";
+    BinaryOperator[BinaryOperator["NotEquals"] = 1] = "NotEquals";
+    BinaryOperator[BinaryOperator["Assign"] = 2] = "Assign";
+    BinaryOperator[BinaryOperator["Identical"] = 3] = "Identical";
+    BinaryOperator[BinaryOperator["NotIdentical"] = 4] = "NotIdentical";
+    BinaryOperator[BinaryOperator["Minus"] = 5] = "Minus";
+    BinaryOperator[BinaryOperator["Plus"] = 6] = "Plus";
+    BinaryOperator[BinaryOperator["Divide"] = 7] = "Divide";
+    BinaryOperator[BinaryOperator["Multiply"] = 8] = "Multiply";
+    BinaryOperator[BinaryOperator["Modulo"] = 9] = "Modulo";
+    BinaryOperator[BinaryOperator["And"] = 10] = "And";
+    BinaryOperator[BinaryOperator["Or"] = 11] = "Or";
+    BinaryOperator[BinaryOperator["BitwiseOr"] = 12] = "BitwiseOr";
+    BinaryOperator[BinaryOperator["BitwiseAnd"] = 13] = "BitwiseAnd";
+    BinaryOperator[BinaryOperator["Lower"] = 14] = "Lower";
+    BinaryOperator[BinaryOperator["LowerEquals"] = 15] = "LowerEquals";
+    BinaryOperator[BinaryOperator["Bigger"] = 16] = "Bigger";
+    BinaryOperator[BinaryOperator["BiggerEquals"] = 17] = "BiggerEquals";
+    BinaryOperator[BinaryOperator["NullishCoalesce"] = 18] = "NullishCoalesce";
+    BinaryOperator[BinaryOperator["Exponentiation"] = 19] = "Exponentiation";
+    BinaryOperator[BinaryOperator["In"] = 20] = "In";
+    BinaryOperator[BinaryOperator["AdditionAssignment"] = 21] = "AdditionAssignment";
+    BinaryOperator[BinaryOperator["SubtractionAssignment"] = 22] = "SubtractionAssignment";
+    BinaryOperator[BinaryOperator["MultiplicationAssignment"] = 23] = "MultiplicationAssignment";
+    BinaryOperator[BinaryOperator["DivisionAssignment"] = 24] = "DivisionAssignment";
+    BinaryOperator[BinaryOperator["RemainderAssignment"] = 25] = "RemainderAssignment";
+    BinaryOperator[BinaryOperator["ExponentiationAssignment"] = 26] = "ExponentiationAssignment";
+    BinaryOperator[BinaryOperator["AndAssignment"] = 27] = "AndAssignment";
+    BinaryOperator[BinaryOperator["OrAssignment"] = 28] = "OrAssignment";
+    BinaryOperator[BinaryOperator["NullishCoalesceAssignment"] = 29] = "NullishCoalesceAssignment";
+})(BinaryOperator || (BinaryOperator = {}));
+function nullSafeIsEquivalent(base, other) {
+    if (base == null || other == null) {
+        return base == other;
+    }
+    return base.isEquivalent(other);
+}
+function areAllEquivalentPredicate(base, other, equivalentPredicate) {
+    const len = base.length;
+    if (len !== other.length) {
+        return false;
+    }
+    for (let i = 0; i < len; i++) {
+        if (!equivalentPredicate(base[i], other[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function areAllEquivalent(base, other) {
+    return areAllEquivalentPredicate(base, other, (baseElement, otherElement) => baseElement.isEquivalent(otherElement));
+}
+class Expression {
+    type;
+    sourceSpan;
+    constructor(type, sourceSpan) {
+        this.type = type || null;
+        this.sourceSpan = sourceSpan || null;
+    }
+    prop(name, sourceSpan) {
+        return new ReadPropExpr(this, name, null, sourceSpan);
+    }
+    key(index, type, sourceSpan) {
+        return new ReadKeyExpr(this, index, type, sourceSpan);
+    }
+    callFn(params, sourceSpan, pure) {
+        return new InvokeFunctionExpr(this, params, null, sourceSpan, pure);
+    }
+    instantiate(params, type, sourceSpan) {
+        return new InstantiateExpr(this, params, type, sourceSpan);
+    }
+    conditional(trueCase, falseCase = null, sourceSpan) {
+        return new ConditionalExpr(this, trueCase, falseCase, null, sourceSpan);
+    }
+    equals(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Equals, this, rhs, null, sourceSpan);
+    }
+    notEquals(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.NotEquals, this, rhs, null, sourceSpan);
+    }
+    identical(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Identical, this, rhs, null, sourceSpan);
+    }
+    notIdentical(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.NotIdentical, this, rhs, null, sourceSpan);
+    }
+    minus(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Minus, this, rhs, null, sourceSpan);
+    }
+    plus(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Plus, this, rhs, null, sourceSpan);
+    }
+    divide(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Divide, this, rhs, null, sourceSpan);
+    }
+    multiply(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Multiply, this, rhs, null, sourceSpan);
+    }
+    modulo(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Modulo, this, rhs, null, sourceSpan);
+    }
+    power(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Exponentiation, this, rhs, null, sourceSpan);
+    }
+    and(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.And, this, rhs, null, sourceSpan);
+    }
+    bitwiseOr(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.BitwiseOr, this, rhs, null, sourceSpan);
+    }
+    bitwiseAnd(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.BitwiseAnd, this, rhs, null, sourceSpan);
+    }
+    or(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Or, this, rhs, null, sourceSpan);
+    }
+    lower(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Lower, this, rhs, null, sourceSpan);
+    }
+    lowerEquals(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.LowerEquals, this, rhs, null, sourceSpan);
+    }
+    bigger(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.Bigger, this, rhs, null, sourceSpan);
+    }
+    biggerEquals(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.BiggerEquals, this, rhs, null, sourceSpan);
+    }
+    isBlank(sourceSpan) {
+        // Note: We use equals by purpose here to compare to null and undefined in JS.
+        // We use the typed null to allow strictNullChecks to narrow types.
+        return this.equals(TYPED_NULL_EXPR, sourceSpan);
+    }
+    nullishCoalesce(rhs, sourceSpan) {
+        return new BinaryOperatorExpr(BinaryOperator.NullishCoalesce, this, rhs, null, sourceSpan);
+    }
+    toStmt() {
+        return new ExpressionStatement(this, null);
+    }
+}
+class InvokeFunctionExpr extends Expression {
+    fn;
+    args;
+    pure;
+    constructor(fn, args, type, sourceSpan, pure = false) {
+        super(type, sourceSpan);
+        this.fn = fn;
+        this.args = args;
+        this.pure = pure;
+    }
+    // An alias for fn, which allows other logic to handle calls and property reads together.
+    get receiver() {
+        return this.fn;
+    }
+    isEquivalent(e) {
+        return (e instanceof InvokeFunctionExpr &&
+            this.fn.isEquivalent(e.fn) &&
+            areAllEquivalent(this.args, e.args) &&
+            this.pure === e.pure);
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitInvokeFunctionExpr(this, context);
+    }
+    clone() {
+        return new InvokeFunctionExpr(this.fn.clone(), this.args.map((arg) => arg.clone()), this.type, this.sourceSpan, this.pure);
+    }
+}
+class InstantiateExpr extends Expression {
+    classExpr;
+    args;
+    constructor(classExpr, args, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.classExpr = classExpr;
+        this.args = args;
+    }
+    isEquivalent(e) {
+        return (e instanceof InstantiateExpr &&
+            this.classExpr.isEquivalent(e.classExpr) &&
+            areAllEquivalent(this.args, e.args));
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitInstantiateExpr(this, context);
+    }
+    clone() {
+        return new InstantiateExpr(this.classExpr.clone(), this.args.map((arg) => arg.clone()), this.type, this.sourceSpan);
+    }
+}
+class LiteralExpr extends Expression {
+    value;
+    constructor(value, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.value = value;
+    }
+    isEquivalent(e) {
+        return e instanceof LiteralExpr && this.value === e.value;
+    }
+    isConstant() {
+        return true;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitLiteralExpr(this, context);
+    }
+    clone() {
+        return new LiteralExpr(this.value, this.type, this.sourceSpan);
+    }
+}
+class ConditionalExpr extends Expression {
+    condition;
+    falseCase;
+    trueCase;
+    constructor(condition, trueCase, falseCase = null, type, sourceSpan) {
+        super(type || trueCase.type, sourceSpan);
+        this.condition = condition;
+        this.falseCase = falseCase;
+        this.trueCase = trueCase;
+    }
+    isEquivalent(e) {
+        return (e instanceof ConditionalExpr &&
+            this.condition.isEquivalent(e.condition) &&
+            this.trueCase.isEquivalent(e.trueCase) &&
+            nullSafeIsEquivalent(this.falseCase, e.falseCase));
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitConditionalExpr(this, context);
+    }
+    clone() {
+        return new ConditionalExpr(this.condition.clone(), this.trueCase.clone(), this.falseCase?.clone(), this.type, this.sourceSpan);
+    }
+}
+class BinaryOperatorExpr extends Expression {
+    operator;
+    rhs;
+    lhs;
+    constructor(operator, lhs, rhs, type, sourceSpan) {
+        super(type || lhs.type, sourceSpan);
+        this.operator = operator;
+        this.rhs = rhs;
+        this.lhs = lhs;
+    }
+    isEquivalent(e) {
+        return (e instanceof BinaryOperatorExpr &&
+            this.operator === e.operator &&
+            this.lhs.isEquivalent(e.lhs) &&
+            this.rhs.isEquivalent(e.rhs));
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitBinaryOperatorExpr(this, context);
+    }
+    clone() {
+        return new BinaryOperatorExpr(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan);
+    }
+    isAssignment() {
+        const op = this.operator;
+        return (op === BinaryOperator.Assign ||
+            op === BinaryOperator.AdditionAssignment ||
+            op === BinaryOperator.SubtractionAssignment ||
+            op === BinaryOperator.MultiplicationAssignment ||
+            op === BinaryOperator.DivisionAssignment ||
+            op === BinaryOperator.RemainderAssignment ||
+            op === BinaryOperator.ExponentiationAssignment ||
+            op === BinaryOperator.AndAssignment ||
+            op === BinaryOperator.OrAssignment ||
+            op === BinaryOperator.NullishCoalesceAssignment);
+    }
+}
+class ReadPropExpr extends Expression {
+    receiver;
+    name;
+    constructor(receiver, name, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.receiver = receiver;
+        this.name = name;
+    }
+    // An alias for name, which allows other logic to handle property reads and keyed reads together.
+    get index() {
+        return this.name;
+    }
+    isEquivalent(e) {
+        return (e instanceof ReadPropExpr && this.receiver.isEquivalent(e.receiver) && this.name === e.name);
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitReadPropExpr(this, context);
+    }
+    set(value) {
+        return new BinaryOperatorExpr(BinaryOperator.Assign, this.receiver.prop(this.name), value, null, this.sourceSpan);
+    }
+    clone() {
+        return new ReadPropExpr(this.receiver.clone(), this.name, this.type, this.sourceSpan);
+    }
+}
+class ReadKeyExpr extends Expression {
+    receiver;
+    index;
+    constructor(receiver, index, type, sourceSpan) {
+        super(type, sourceSpan);
+        this.receiver = receiver;
+        this.index = index;
+    }
+    isEquivalent(e) {
+        return (e instanceof ReadKeyExpr &&
+            this.receiver.isEquivalent(e.receiver) &&
+            this.index.isEquivalent(e.index));
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitReadKeyExpr(this, context);
+    }
+    set(value) {
+        return new BinaryOperatorExpr(BinaryOperator.Assign, this.receiver.key(this.index), value, null, this.sourceSpan);
+    }
+    clone() {
+        return new ReadKeyExpr(this.receiver.clone(), this.index.clone(), this.type, this.sourceSpan);
+    }
+}
+const NULL_EXPR = new LiteralExpr(null, null, null);
+const TYPED_NULL_EXPR = new LiteralExpr(null, INFERRED_TYPE, null);
+//// Statements
+var StmtModifier;
+(function (StmtModifier) {
+    StmtModifier[StmtModifier["None"] = 0] = "None";
+    StmtModifier[StmtModifier["Final"] = 1] = "Final";
+    StmtModifier[StmtModifier["Private"] = 2] = "Private";
+    StmtModifier[StmtModifier["Exported"] = 4] = "Exported";
+    StmtModifier[StmtModifier["Static"] = 8] = "Static";
+})(StmtModifier || (StmtModifier = {}));
+class Statement {
+    modifiers;
+    sourceSpan;
+    leadingComments;
+    constructor(modifiers = StmtModifier.None, sourceSpan = null, leadingComments) {
+        this.modifiers = modifiers;
+        this.sourceSpan = sourceSpan;
+        this.leadingComments = leadingComments;
+    }
+    hasModifier(modifier) {
+        return (this.modifiers & modifier) !== 0;
+    }
+    addLeadingComment(leadingComment) {
+        this.leadingComments = this.leadingComments ?? [];
+        this.leadingComments.push(leadingComment);
+    }
+}
+class ExpressionStatement extends Statement {
+    expr;
+    constructor(expr, sourceSpan, leadingComments) {
+        super(StmtModifier.None, sourceSpan, leadingComments);
+        this.expr = expr;
+    }
+    isEquivalent(stmt) {
+        return stmt instanceof ExpressionStatement && this.expr.isEquivalent(stmt.expr);
+    }
+    visitStatement(visitor, context) {
+        return visitor.visitExpressionStmt(this, context);
+    }
+}
+
 /**
  * Detects `spyOn(dirInstance, 'myInput')` calls that likely modify
  * the input signal. There is no way to change the value inside the input signal,
@@ -135,8 +568,8 @@ function checkIncompatiblePatterns(inheritanceGraph, checker, groupedTsAstVisito
     const spyOnPattern = new SpyOnFieldPattern(checker, fields);
     const visitor = (node) => {
         // Check for manual class instantiations.
-        if (ts.isNewExpression(node) && ts.isIdentifier(project_tsconfig_paths.unwrapExpression(node.expression))) {
-            let newTarget = checker.getSymbolAtLocation(project_tsconfig_paths.unwrapExpression(node.expression));
+        if (ts.isNewExpression(node) && ts.isIdentifier(migrations.unwrapExpression(node.expression))) {
+            let newTarget = checker.getSymbolAtLocation(migrations.unwrapExpression(node.expression));
             // Plain identifier references can point to alias symbols (e.g. imports).
             if (newTarget !== undefined && newTarget.flags & ts.SymbolFlags.Alias) {
                 newTarget = checker.getAliasedSymbol(newTarget);
@@ -155,7 +588,7 @@ function checkIncompatiblePatterns(inheritanceGraph, checker, groupedTsAstVisito
         problematicReferencesCheck: if (insidePropertyDeclaration !== null &&
             ts.isIdentifier(node) &&
             insidePropertyDeclaration.parent.heritageClauses !== undefined) {
-            let newTarget = checker.getSymbolAtLocation(project_tsconfig_paths.unwrapExpression(node));
+            let newTarget = checker.getSymbolAtLocation(migrations.unwrapExpression(node));
             // Plain identifier references can point to alias symbols (e.g. imports).
             if (newTarget !== undefined && newTarget.flags & ts.SymbolFlags.Alias) {
                 newTarget = checker.getAliasedSymbol(newTarget);
@@ -384,7 +817,7 @@ function checkInheritanceOfKnownFields(inheritanceGraph, metaRegistry, fields, o
         if (metaRegistry !== null) {
             for (const derivedClasses of inheritanceGraph.traceDerivedClasses(inputClass)) {
                 const derivedMeta = ts.isClassDeclaration(derivedClasses) && derivedClasses.name !== undefined
-                    ? metaRegistry.getDirectiveMetadata(new project_tsconfig_paths.Reference(derivedClasses))
+                    ? metaRegistry.getDirectiveMetadata(new migrations.Reference(derivedClasses))
                     : null;
                 if (derivedMeta !== null && derivedMeta.inputFieldNamesFromMetadataArray !== null) {
                     derivedMeta.inputFieldNamesFromMetadataArray.forEach((b) => inputFieldNamesFromMetadataArray.add(b));
@@ -430,18 +863,6 @@ function checkInheritanceOfKnownFields(inheritanceGraph, metaRegistry, fields, o
     }
 }
 
-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.factory.updateUnionTypeNode(union, ts.factory.createNodeArray(filtered));
-}
-
 /**
  * Inserts a leading string for the given node, respecting
  * indentation of the given anchor node.
@@ -482,6 +903,18 @@ function cutStringToLineLimit(str, limit) {
     return chunks;
 }
 
+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.factory.updateUnionTypeNode(union, ts.factory.createNodeArray(filtered));
+}
+
 /**
  * Gets human-readable message information for the given field incompatibility.
  * This text will be used by the language service, or CLI-based migration.
@@ -1521,6 +1954,7 @@ function migrateTypeScriptTypeReferences(host, references, importManager, info)
 
 exports.GroupedTsAstVisitor = GroupedTsAstVisitor;
 exports.InheritanceGraph = InheritanceGraph;
+exports.NULL_EXPR = NULL_EXPR;
 exports.checkIncompatiblePatterns = checkIncompatiblePatterns;
 exports.checkInheritanceOfKnownFields = checkInheritanceOfKnownFields;
 exports.cutStringToLineLimit = cutStringToLineLimit;

package/schematics/bundles/{ng_component_template-BkWiUuGG.cjs → ng_component_template-Dsuq1Lw7.cjs}

@@ -1,16 +1,15 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.8
+ * @license Angular v21.0.0-rc.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 var ts = require('typescript');
-var ng_decorators = require('./ng_decorators-BI0uV7KI.cjs');
+var compilerCli = require('@angular/compiler-cli');
+var ng_decorators = require('./ng_decorators-DSFlWYQY.cjs');
 var property_name = require('./property_name-BBwFuqMe.cjs');
-require('os');
-var project_tsconfig_paths = require('./project_tsconfig_paths-CdhVNYMk.cjs');
 
 /**
  * Unwraps a given expression TypeScript node. Expressions can be wrapped within multiple
@@ -116,7 +115,7 @@ function findClosestLineStartPosition(linesMap, position, low = 0, high = linesM
 class NgComponentTemplateVisitor {
     typeChecker;
     resolvedTemplates = [];
-    fs = project_tsconfig_paths.getFileSystem();
+    fs = compilerCli.getFileSystem();
     constructor(typeChecker) {
         this.typeChecker = typeChecker;
     }

package/schematics/bundles/{ng_decorators-BI0uV7KI.cjs → ng_decorators-DSFlWYQY.cjs}

@@ -1,13 +1,13 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.8
+ * @license Angular v21.0.0-rc.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 var ts = require('typescript');
-var imports = require('./imports-DwPXlGFl.cjs');
+var imports = require('./imports-DP72APSx.cjs');
 
 function getCallDecoratorImport(typeChecker, decorator) {
     // Note that this does not cover the edge case where decorators are called from

package/schematics/bundles/ngclass-to-class-migration.cjs

@@ -1,29 +1,26 @@
 'use strict';
 /**
- * @license Angular v21.0.0-next.8
+ * @license Angular v21.0.0-rc.0
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 'use strict';
 
 var ts = require('typescript');
-require('os');
-var project_tsconfig_paths = require('./project_tsconfig_paths-CdhVNYMk.cjs');
-var index = require('./index-BnmACOsq.cjs');
-require('path');
+require('@angular/compiler-cli');
+var migrations = require('@angular/compiler-cli/private/migrations');
 require('node:path');
-var project_paths = require('./project_paths-C6g3lqjX.cjs');
-var apply_import_manager = require('./apply_import_manager-CBLmogDD.cjs');
-var imports = require('./imports-DwPXlGFl.cjs');
-var parse_html = require('./parse_html-C97tKKp3.cjs');
-var ng_component_template = require('./ng_component_template-BkWiUuGG.cjs');
+var project_paths = require('./project_paths-DvD50ouC.cjs');
+var compiler = require('@angular/compiler');
+var apply_import_manager = require('./apply_import_manager-1Zs_gpB6.cjs');
+var imports = require('./imports-DP72APSx.cjs');
+var parse_html = require('./parse_html-8VLCL37B.cjs');
+var ng_component_template = require('./ng_component_template-Dsuq1Lw7.cjs');
 require('@angular-devkit/core');
 require('node:path/posix');
-require('fs');
-require('module');
-require('url');
 require('@angular-devkit/schematics');
-require('./ng_decorators-BI0uV7KI.cjs');
+require('./project_tsconfig_paths-CDVxT6Ov.cjs');
+require('./ng_decorators-DSFlWYQY.cjs');
 require('./property_name-BBwFuqMe.cjs');
 
 const ngClassStr = 'NgClass';
@@ -35,7 +32,7 @@ function migrateNgClassBindings(template, config, componentNode, typeChecker) {
         return { migrated: template, changed: false, replacementCount: 0, canRemoveCommonModule: false };
     }
     const visitor = new NgClassCollector(template, componentNode, typeChecker);
-    project_tsconfig_paths.visitAll$1(visitor, parsed.tree.rootNodes, config);
+    compiler.visitAll(visitor, parsed.tree.rootNodes, config);
     let newTemplate = template;
     let changedOffset = 0;
     let replacementCount = 0;
@@ -58,8 +55,8 @@ function migrateNgClassBindings(template, config, componentNode, typeChecker) {
  * Uses ReflectionHost + PartialEvaluator for robust AST analysis.
  */
 function createNgClassImportsArrayRemoval(classNode, file, typeChecker, removeCommonModule) {
-    const reflector = new project_tsconfig_paths.TypeScriptReflectionHost(typeChecker);
-    const evaluator = new index.PartialEvaluator(reflector, typeChecker, null);
+    const reflector = new migrations.TypeScriptReflectionHost(typeChecker);
+    const evaluator = new migrations.PartialEvaluator(reflector, typeChecker, null);
     // Use ReflectionHost to get decorators instead of manual AST traversal
     const decorators = reflector.getDecoratorsOfDeclaration(classNode);
     if (!decorators) {
@@ -133,7 +130,7 @@ function getPropertyRemovalRange(property) {
 }
 function calculateImportReplacements(info, sourceFiles, filesToRemoveCommonModule) {
     const importReplacements = {};
-    const importManager = new project_tsconfig_paths.ImportManager();
+    const importManager = new migrations.ImportManager();
     for (const sf of sourceFiles) {
         const file = project_paths.projectFile(sf, info);
         // Always remove NgClass if it's imported directly.
@@ -160,7 +157,7 @@ function replaceTemplate(template, replaceValue, start, end, offset) {
  * Visitor class that scans Angular templates and collects replacements
  * for [ngClass] bindings that use static object literals.
  */
-class NgClassCollector extends project_tsconfig_paths.RecursiveVisitor$1 {
+class NgClassCollector extends compiler.RecursiveVisitor {
     componentNode;
     typeChecker;
     replacements = [];