static-injector 2.1.1 → 2.2.1

package/transform/compiler/src/output/output_ast.js

@@ -7,15 +7,16 @@
  * found in the LICENSE file at https://angular.io/license
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LeadingComment = exports.StmtModifier = exports.TYPED_NULL_EXPR = exports.NULL_EXPR = exports.CommaExpr = exports.LiteralMapExpr = exports.LiteralMapEntry = exports.LiteralArrayExpr = exports.ReadKeyExpr = exports.ReadPropExpr = exports.BinaryOperatorExpr = exports.UnaryOperatorExpr = exports.FunctionExpr = exports.FnParam = exports.NotExpr = exports.ConditionalExpr = exports.ExternalReference = exports.ExternalExpr = exports.LiteralPiece = exports.TemplateLiteralElement = exports.TemplateLiteral = exports.LiteralExpr = exports.InstantiateExpr = exports.InvokeFunctionExpr = exports.WritePropExpr = exports.WriteKeyExpr = exports.WriteVarExpr = exports.WrappedNodeExpr = exports.TypeofExpr = exports.ReadVarExpr = exports.Expression = exports.areAllEquivalent = exports.nullSafeIsEquivalent = exports.BinaryOperator = exports.UnaryOperator = exports.NONE_TYPE = exports.FUNCTION_TYPE = exports.STRING_TYPE = exports.NUMBER_TYPE = exports.INT_TYPE = exports.BOOL_TYPE = exports.INFERRED_TYPE = exports.DYNAMIC_TYPE = exports.MapType = exports.ArrayType = exports.ExpressionType = exports.BuiltinType = exports.BuiltinTypeName = exports.Type = exports.TypeModifier = void 0;
-exports.isNull = exports.literal = exports.ifStmt = exports.fn = exports.not = exports.unary = exports.literalMap = exports.literalArr = exports.typeofExpr = exports.expressionType = exports.importType = exports.importExpr = exports.variable = exports.jsDocComment = exports.leadingComment = exports.IfStmt = exports.ReturnStatement = exports.ExpressionStatement = exports.DeclareFunctionStmt = exports.DeclareVarStmt = exports.Statement = exports.JSDocComment = void 0;
+exports.TYPED_NULL_EXPR = exports.NULL_EXPR = exports.CommaExpr = exports.LiteralMapExpr = exports.LiteralMapEntry = exports.LiteralArrayExpr = exports.ReadKeyExpr = exports.ReadPropExpr = exports.BinaryOperatorExpr = exports.UnaryOperatorExpr = exports.FunctionExpr = exports.FnParam = exports.NotExpr = exports.DynamicImportExpr = exports.ConditionalExpr = exports.ExternalReference = exports.ExternalExpr = exports.LiteralPiece = exports.TemplateLiteralElement = exports.TemplateLiteral = exports.LiteralExpr = exports.InstantiateExpr = exports.InvokeFunctionExpr = exports.WritePropExpr = exports.WriteKeyExpr = exports.WriteVarExpr = exports.WrappedNodeExpr = exports.TypeofExpr = exports.ReadVarExpr = exports.Expression = exports.areAllEquivalent = exports.nullSafeIsEquivalent = exports.BinaryOperator = exports.UnaryOperator = exports.NONE_TYPE = exports.FUNCTION_TYPE = exports.STRING_TYPE = exports.NUMBER_TYPE = exports.INT_TYPE = exports.BOOL_TYPE = exports.INFERRED_TYPE = exports.DYNAMIC_TYPE = exports.TransplantedType = exports.MapType = exports.ArrayType = exports.ExpressionType = exports.BuiltinType = exports.BuiltinTypeName = exports.Type = exports.TypeModifier = void 0;
+exports.isNull = exports.literal = exports.ifStmt = exports.fn = exports.not = exports.unary = exports.literalMap = exports.literalArr = exports.typeofExpr = exports.transplantedType = exports.expressionType = exports.importType = exports.importExpr = exports.variable = exports.jsDocComment = exports.leadingComment = exports.IfStmt = exports.ReturnStatement = exports.ExpressionStatement = exports.DeclareFunctionStmt = exports.DeclareVarStmt = exports.Statement = exports.JSDocComment = exports.LeadingComment = exports.StmtModifier = void 0;
 //// Types
 var TypeModifier;
 (function (TypeModifier) {
     TypeModifier[TypeModifier["None"] = 0] = "None";
     TypeModifier[TypeModifier["Const"] = 1] = "Const";
-})(TypeModifier = exports.TypeModifier || (exports.TypeModifier = {}));
+})(TypeModifier || (exports.TypeModifier = TypeModifier = {}));
 class Type {
+    modifiers;
     constructor(modifiers = TypeModifier.None) {
         this.modifiers = modifiers;
     }
@@ -34,8 +35,9 @@ var BuiltinTypeName;
     BuiltinTypeName[BuiltinTypeName["Function"] = 5] = "Function";
     BuiltinTypeName[BuiltinTypeName["Inferred"] = 6] = "Inferred";
     BuiltinTypeName[BuiltinTypeName["None"] = 7] = "None";
-})(BuiltinTypeName = exports.BuiltinTypeName || (exports.BuiltinTypeName = {}));
+})(BuiltinTypeName || (exports.BuiltinTypeName = BuiltinTypeName = {}));
 class BuiltinType extends Type {
+    name;
     constructor(name, modifiers) {
         super(modifiers);
         this.name = name;
@@ -46,6 +48,8 @@ class BuiltinType extends Type {
 }
 exports.BuiltinType = BuiltinType;
 class ExpressionType extends Type {
+    value;
+    typeParams;
     constructor(value, modifiers, typeParams = null) {
         super(modifiers);
         this.value = value;
@@ -57,6 +61,7 @@ class ExpressionType extends Type {
 }
 exports.ExpressionType = ExpressionType;
 class ArrayType extends Type {
+    of;
     constructor(of, modifiers) {
         super(modifiers);
         this.of = of;
@@ -67,6 +72,7 @@ class ArrayType extends Type {
 }
 exports.ArrayType = ArrayType;
 class MapType extends Type {
+    valueType;
     constructor(valueType, modifiers) {
         super(modifiers);
         this.valueType = valueType || null;
@@ -76,6 +82,17 @@ class MapType extends Type {
     }
 }
 exports.MapType = MapType;
+class TransplantedType extends Type {
+    type;
+    constructor(type, modifiers) {
+        super(modifiers);
+        this.type = type;
+    }
+    visitType(visitor, context) {
+        return visitor.visitTransplantedType(this, context);
+    }
+}
+exports.TransplantedType = TransplantedType;
 exports.DYNAMIC_TYPE = new BuiltinType(BuiltinTypeName.Dynamic);
 exports.INFERRED_TYPE = new BuiltinType(BuiltinTypeName.Inferred);
 exports.BOOL_TYPE = new BuiltinType(BuiltinTypeName.Bool);
@@ -89,7 +106,7 @@ var UnaryOperator;
 (function (UnaryOperator) {
     UnaryOperator[UnaryOperator["Minus"] = 0] = "Minus";
     UnaryOperator[UnaryOperator["Plus"] = 1] = "Plus";
-})(UnaryOperator = exports.UnaryOperator || (exports.UnaryOperator = {}));
+})(UnaryOperator || (exports.UnaryOperator = UnaryOperator = {}));
 var BinaryOperator;
 (function (BinaryOperator) {
     BinaryOperator[BinaryOperator["Equals"] = 0] = "Equals";
@@ -109,7 +126,7 @@ var BinaryOperator;
     BinaryOperator[BinaryOperator["Bigger"] = 14] = "Bigger";
     BinaryOperator[BinaryOperator["BiggerEquals"] = 15] = "BiggerEquals";
     BinaryOperator[BinaryOperator["NullishCoalesce"] = 16] = "NullishCoalesce";
-})(BinaryOperator = exports.BinaryOperator || (exports.BinaryOperator = {}));
+})(BinaryOperator || (exports.BinaryOperator = BinaryOperator = {}));
 function nullSafeIsEquivalent(base, other) {
     if (base == null || other == null) {
         return base == other;
@@ -134,6 +151,8 @@ function areAllEquivalent(base, other) {
 }
 exports.areAllEquivalent = areAllEquivalent;
 class Expression {
+    type;
+    sourceSpan;
     constructor(type, sourceSpan) {
         this.type = type || null;
         this.sourceSpan = sourceSpan || null;
@@ -153,6 +172,7 @@ class Expression {
 }
 exports.Expression = Expression;
 class ReadVarExpr extends Expression {
+    name;
     constructor(name, type, sourceSpan) {
         super(type, sourceSpan);
         this.name = name;
@@ -166,12 +186,16 @@ class ReadVarExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitReadVarExpr(this, context);
     }
+    clone() {
+        return new ReadVarExpr(this.name, this.type, this.sourceSpan);
+    }
     set(value) {
         return new WriteVarExpr(this.name, value, null, this.sourceSpan);
     }
 }
 exports.ReadVarExpr = ReadVarExpr;
 class TypeofExpr extends Expression {
+    expr;
     constructor(expr, type, sourceSpan) {
         super(type, sourceSpan);
         this.expr = expr;
@@ -185,9 +209,13 @@ class TypeofExpr extends Expression {
     isConstant() {
         return this.expr.isConstant();
     }
+    clone() {
+        return new TypeofExpr(this.expr.clone());
+    }
 }
 exports.TypeofExpr = TypeofExpr;
 class WrappedNodeExpr extends Expression {
+    node;
     constructor(node, type, sourceSpan) {
         super(type, sourceSpan);
         this.node = node;
@@ -201,9 +229,14 @@ class WrappedNodeExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitWrappedNodeExpr(this, context);
     }
+    clone() {
+        return new WrappedNodeExpr(this.node, this.type, this.sourceSpan);
+    }
 }
 exports.WrappedNodeExpr = WrappedNodeExpr;
 class WriteVarExpr extends Expression {
+    name;
+    value;
     constructor(name, value, type, sourceSpan) {
         super(type || value.type, sourceSpan);
         this.name = name;
@@ -220,6 +253,9 @@ class WriteVarExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitWriteVarExpr(this, context);
     }
+    clone() {
+        return new WriteVarExpr(this.name, this.value.clone(), this.type, this.sourceSpan);
+    }
     toDeclStmt(type, modifiers) {
         return new DeclareVarStmt(this.name, this.value, type, modifiers, this.sourceSpan);
     }
@@ -229,6 +265,9 @@ class WriteVarExpr extends Expression {
 }
 exports.WriteVarExpr = WriteVarExpr;
 class WriteKeyExpr extends Expression {
+    receiver;
+    index;
+    value;
     constructor(receiver, index, value, type, sourceSpan) {
         super(type || value.type, sourceSpan);
         this.receiver = receiver;
@@ -247,9 +286,15 @@ class WriteKeyExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitWriteKeyExpr(this, context);
     }
+    clone() {
+        return new WriteKeyExpr(this.receiver.clone(), this.index.clone(), this.value.clone(), this.type, this.sourceSpan);
+    }
 }
 exports.WriteKeyExpr = WriteKeyExpr;
 class WritePropExpr extends Expression {
+    receiver;
+    name;
+    value;
     constructor(receiver, name, value, type, sourceSpan) {
         super(type || value.type, sourceSpan);
         this.receiver = receiver;
@@ -268,15 +313,25 @@ class WritePropExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitWritePropExpr(this, context);
     }
+    clone() {
+        return new WritePropExpr(this.receiver.clone(), this.name, this.value.clone(), this.type, this.sourceSpan);
+    }
 }
 exports.WritePropExpr = WritePropExpr;
 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) &&
@@ -289,9 +344,14 @@ class InvokeFunctionExpr extends Expression {
     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);
+    }
 }
 exports.InvokeFunctionExpr = InvokeFunctionExpr;
 class InstantiateExpr extends Expression {
+    classExpr;
+    args;
     constructor(classExpr, args, type, sourceSpan) {
         super(type, sourceSpan);
         this.classExpr = classExpr;
@@ -308,9 +368,13 @@ class InstantiateExpr extends Expression {
     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);
+    }
 }
 exports.InstantiateExpr = InstantiateExpr;
 class LiteralExpr extends Expression {
+    value;
     constructor(value, type, sourceSpan) {
         super(type, sourceSpan);
         this.value = value;
@@ -324,18 +388,28 @@ class LiteralExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitLiteralExpr(this, context);
     }
+    clone() {
+        return new LiteralExpr(this.value, this.type, this.sourceSpan);
+    }
 }
 exports.LiteralExpr = LiteralExpr;
 class TemplateLiteral {
+    elements;
+    expressions;
     constructor(elements, expressions) {
         this.elements = elements;
         this.expressions = expressions;
     }
+    clone() {
+        return new TemplateLiteral(this.elements.map((el) => el.clone()), this.expressions.map((expr) => expr.clone()));
+    }
 }
 exports.TemplateLiteral = TemplateLiteral;
 class TemplateLiteralElement {
+    text;
+    sourceSpan;
+    rawText;
     constructor(text, sourceSpan, rawText) {
-        var _a;
         this.text = text;
         this.sourceSpan = sourceSpan;
         // If `rawText` is not provided, try to extract the raw string from its
@@ -345,11 +419,18 @@ class TemplateLiteralElement {
         // - "`" and "${" are template string control sequences that would otherwise prematurely
         // indicate the end of the template literal element.
         this.rawText =
-            (_a = rawText !== null && rawText !== void 0 ? rawText : sourceSpan === null || sourceSpan === void 0 ? void 0 : sourceSpan.toString()) !== null && _a !== void 0 ? _a : escapeForTemplateLiteral(escapeSlashes(text));
+            rawText ??
+                sourceSpan?.toString() ??
+                escapeForTemplateLiteral(escapeSlashes(text));
+    }
+    clone() {
+        return new TemplateLiteralElement(this.text, this.sourceSpan, this.rawText);
     }
 }
 exports.TemplateLiteralElement = TemplateLiteralElement;
 class LiteralPiece {
+    text;
+    sourceSpan;
     constructor(text, sourceSpan) {
         this.text = text;
         this.sourceSpan = sourceSpan;
@@ -391,6 +472,8 @@ function createCookedRawString(metaBlock, messagePart, range) {
     }
 }
 class ExternalExpr extends Expression {
+    value;
+    typeParams;
     constructor(value, type, typeParams = null, sourceSpan) {
         super(type, sourceSpan);
         this.value = value;
@@ -408,9 +491,15 @@ class ExternalExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitExternalExpr(this, context);
     }
+    clone() {
+        return new ExternalExpr(this.value, this.type, this.typeParams, this.sourceSpan);
+    }
 }
 exports.ExternalExpr = ExternalExpr;
 class ExternalReference {
+    moduleName;
+    name;
+    runtime;
     constructor(moduleName, name, runtime) {
         this.moduleName = moduleName;
         this.name = name;
@@ -419,6 +508,9 @@ class ExternalReference {
 }
 exports.ExternalReference = ExternalReference;
 class ConditionalExpr extends Expression {
+    condition;
+    falseCase;
+    trueCase;
     constructor(condition, trueCase, falseCase = null, type, sourceSpan) {
         super(type || trueCase.type, sourceSpan);
         this.condition = condition;
@@ -437,9 +529,33 @@ class ConditionalExpr extends Expression {
     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);
+    }
 }
 exports.ConditionalExpr = ConditionalExpr;
+class DynamicImportExpr extends Expression {
+    url;
+    constructor(url, sourceSpan) {
+        super(null, sourceSpan);
+        this.url = url;
+    }
+    isEquivalent(e) {
+        return e instanceof DynamicImportExpr && this.url === e.url;
+    }
+    isConstant() {
+        return false;
+    }
+    visitExpression(visitor, context) {
+        return visitor.visitDynamicImportExpr(this, context);
+    }
+    clone() {
+        return new DynamicImportExpr(this.url, this.sourceSpan);
+    }
+}
+exports.DynamicImportExpr = DynamicImportExpr;
 class NotExpr extends Expression {
+    condition;
     constructor(condition, sourceSpan) {
         super(exports.BOOL_TYPE, sourceSpan);
         this.condition = condition;
@@ -453,9 +569,14 @@ class NotExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitNotExpr(this, context);
     }
+    clone() {
+        return new NotExpr(this.condition.clone(), this.sourceSpan);
+    }
 }
 exports.NotExpr = NotExpr;
 class FnParam {
+    name;
+    type;
     constructor(name, type = null) {
         this.name = name;
         this.type = type;
@@ -463,9 +584,15 @@ class FnParam {
     isEquivalent(param) {
         return this.name === param.name;
     }
+    clone() {
+        return new FnParam(this.name, this.type);
+    }
 }
 exports.FnParam = FnParam;
 class FunctionExpr extends Expression {
+    params;
+    statements;
+    name;
     constructor(params, statements, type, sourceSpan, name) {
         super(type, sourceSpan);
         this.params = params;
@@ -486,9 +613,16 @@ class FunctionExpr extends Expression {
     toDeclStmt(name, modifiers) {
         return new DeclareFunctionStmt(name, this.params, this.statements, this.type, modifiers, this.sourceSpan);
     }
+    clone() {
+        // TODO: Should we deep clone statements?
+        return new FunctionExpr(this.params.map((p) => p.clone()), this.statements, this.type, this.sourceSpan, this.name);
+    }
 }
 exports.FunctionExpr = FunctionExpr;
 class UnaryOperatorExpr extends Expression {
+    operator;
+    expr;
+    parens;
     constructor(operator, expr, type, sourceSpan, parens = true) {
         super(type || exports.NUMBER_TYPE, sourceSpan);
         this.operator = operator;
@@ -506,9 +640,16 @@ class UnaryOperatorExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitUnaryOperatorExpr(this, context);
     }
+    clone() {
+        return new UnaryOperatorExpr(this.operator, this.expr.clone(), this.type, this.sourceSpan, this.parens);
+    }
 }
 exports.UnaryOperatorExpr = UnaryOperatorExpr;
 class BinaryOperatorExpr extends Expression {
+    operator;
+    rhs;
+    parens;
+    lhs;
     constructor(operator, lhs, rhs, type, sourceSpan, parens = true) {
         super(type || lhs.type, sourceSpan);
         this.operator = operator;
@@ -528,14 +669,23 @@ class BinaryOperatorExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitBinaryOperatorExpr(this, context);
     }
+    clone() {
+        return new BinaryOperatorExpr(this.operator, this.lhs.clone(), this.rhs.clone(), this.type, this.sourceSpan, this.parens);
+    }
 }
 exports.BinaryOperatorExpr = BinaryOperatorExpr;
 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) &&
@@ -550,9 +700,14 @@ class ReadPropExpr extends Expression {
     set(value) {
         return new WritePropExpr(this.receiver, this.name, value, null, this.sourceSpan);
     }
+    clone() {
+        return new ReadPropExpr(this.receiver.clone(), this.name, this.type, this.sourceSpan);
+    }
 }
 exports.ReadPropExpr = ReadPropExpr;
 class ReadKeyExpr extends Expression {
+    receiver;
+    index;
     constructor(receiver, index, type, sourceSpan) {
         super(type, sourceSpan);
         this.receiver = receiver;
@@ -572,9 +727,13 @@ class ReadKeyExpr extends Expression {
     set(value) {
         return new WriteKeyExpr(this.receiver, this.index, value, null, this.sourceSpan);
     }
+    clone() {
+        return new ReadKeyExpr(this.receiver.clone(), this.index.clone(), this.type, this.sourceSpan);
+    }
 }
 exports.ReadKeyExpr = ReadKeyExpr;
 class LiteralArrayExpr extends Expression {
+    entries;
     constructor(entries, type, sourceSpan) {
         super(type, sourceSpan);
         this.entries = entries;
@@ -588,9 +747,15 @@ class LiteralArrayExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitLiteralArrayExpr(this, context);
     }
+    clone() {
+        return new LiteralArrayExpr(this.entries.map((e) => e.clone()), this.type, this.sourceSpan);
+    }
 }
 exports.LiteralArrayExpr = LiteralArrayExpr;
 class LiteralMapEntry {
+    key;
+    value;
+    quoted;
     constructor(key, value, quoted) {
         this.key = key;
         this.value = value;
@@ -599,13 +764,17 @@ class LiteralMapEntry {
     isEquivalent(e) {
         return this.key === e.key && this.value.isEquivalent(e.value);
     }
+    clone() {
+        return new LiteralMapEntry(this.key, this.value.clone(), this.quoted);
+    }
 }
 exports.LiteralMapEntry = LiteralMapEntry;
 class LiteralMapExpr extends Expression {
+    entries;
+    valueType = null;
     constructor(entries, type, sourceSpan) {
         super(type, sourceSpan);
         this.entries = entries;
-        this.valueType = null;
         if (type) {
             this.valueType = type.valueType;
         }
@@ -619,9 +788,14 @@ class LiteralMapExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitLiteralMapExpr(this, context);
     }
+    clone() {
+        const entriesClone = this.entries.map((entry) => entry.clone());
+        return new LiteralMapExpr(entriesClone, this.type, this.sourceSpan);
+    }
 }
 exports.LiteralMapExpr = LiteralMapExpr;
 class CommaExpr extends Expression {
+    parts;
     constructor(parts, sourceSpan) {
         super(parts[parts.length - 1].type, sourceSpan);
         this.parts = parts;
@@ -635,6 +809,9 @@ class CommaExpr extends Expression {
     visitExpression(visitor, context) {
         return visitor.visitCommaExpr(this, context);
     }
+    clone() {
+        return new CommaExpr(this.parts.map((p) => p.clone()));
+    }
 }
 exports.CommaExpr = CommaExpr;
 exports.NULL_EXPR = new LiteralExpr(null, null, null);
@@ -647,8 +824,11 @@ var StmtModifier;
     StmtModifier[StmtModifier["Private"] = 2] = "Private";
     StmtModifier[StmtModifier["Exported"] = 4] = "Exported";
     StmtModifier[StmtModifier["Static"] = 8] = "Static";
-})(StmtModifier = exports.StmtModifier || (exports.StmtModifier = {}));
+})(StmtModifier || (exports.StmtModifier = StmtModifier = {}));
 class LeadingComment {
+    text;
+    multiline;
+    trailingNewline;
     constructor(text, multiline, trailingNewline) {
         this.text = text;
         this.multiline = multiline;
@@ -660,6 +840,7 @@ class LeadingComment {
 }
 exports.LeadingComment = LeadingComment;
 class JSDocComment extends LeadingComment {
+    tags;
     constructor(tags) {
         super('', /* multiline */ true, /* trailingNewline */ true);
         this.tags = tags;
@@ -670,6 +851,9 @@ class JSDocComment extends LeadingComment {
 }
 exports.JSDocComment = JSDocComment;
 class Statement {
+    modifiers;
+    sourceSpan;
+    leadingComments;
     constructor(modifiers = StmtModifier.None, sourceSpan = null, leadingComments) {
         this.modifiers = modifiers;
         this.sourceSpan = sourceSpan;
@@ -679,13 +863,15 @@ class Statement {
         return (this.modifiers & modifier) !== 0;
     }
     addLeadingComment(leadingComment) {
-        var _a;
-        this.leadingComments = (_a = this.leadingComments) !== null && _a !== void 0 ? _a : [];
+        this.leadingComments = this.leadingComments ?? [];
         this.leadingComments.push(leadingComment);
     }
 }
 exports.Statement = Statement;
 class DeclareVarStmt extends Statement {
+    name;
+    value;
+    type;
     constructor(name, value, type, modifiers, sourceSpan, leadingComments) {
         super(modifiers, sourceSpan, leadingComments);
         this.name = name;
@@ -705,6 +891,10 @@ class DeclareVarStmt extends Statement {
 }
 exports.DeclareVarStmt = DeclareVarStmt;
 class DeclareFunctionStmt extends Statement {
+    name;
+    params;
+    statements;
+    type;
     constructor(name, params, statements, type, modifiers, sourceSpan, leadingComments) {
         super(modifiers, sourceSpan, leadingComments);
         this.name = name;
@@ -723,6 +913,7 @@ class DeclareFunctionStmt extends Statement {
 }
 exports.DeclareFunctionStmt = DeclareFunctionStmt;
 class ExpressionStatement extends Statement {
+    expr;
     constructor(expr, sourceSpan, leadingComments) {
         super(StmtModifier.None, sourceSpan, leadingComments);
         this.expr = expr;
@@ -736,6 +927,7 @@ class ExpressionStatement extends Statement {
 }
 exports.ExpressionStatement = ExpressionStatement;
 class ReturnStatement extends Statement {
+    value;
     constructor(value, sourceSpan = null, leadingComments) {
         super(StmtModifier.None, sourceSpan, leadingComments);
         this.value = value;
@@ -749,6 +941,9 @@ class ReturnStatement extends Statement {
 }
 exports.ReturnStatement = ReturnStatement;
 class IfStmt extends Statement {
+    condition;
+    trueCase;
+    falseCase;
     constructor(condition, trueCase, falseCase = [], sourceSpan, leadingComments) {
         super(StmtModifier.None, sourceSpan, leadingComments);
         this.condition = condition;
@@ -792,6 +987,10 @@ function expressionType(expr, typeModifiers, typeParams) {
     return new ExpressionType(expr, typeModifiers, typeParams);
 }
 exports.expressionType = expressionType;
+function transplantedType(type, typeModifiers) {
+    return new TransplantedType(type, typeModifiers);
+}
+exports.transplantedType = transplantedType;
 function typeofExpr(expr) {
     return new TypeofExpr(expr);
 }

package/transform/compiler/src/parse_util.js

@@ -9,6 +9,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParseSourceSpan = exports.ParseSourceFile = exports.ParseLocation = void 0;
 class ParseLocation {
+    file;
+    offset;
+    line;
+    col;
     constructor(file, offset, line, col) {
         this.file = file;
         this.offset = offset;
@@ -18,6 +22,8 @@ class ParseLocation {
 }
 exports.ParseLocation = ParseLocation;
 class ParseSourceFile {
+    content;
+    url;
     constructor(content, url) {
         this.content = content;
         this.url = url;
@@ -25,6 +31,10 @@ class ParseSourceFile {
 }
 exports.ParseSourceFile = ParseSourceFile;
 class ParseSourceSpan {
+    start;
+    end;
+    fullStart;
+    details;
     /**
      * Create an object that holds information about spans of tokens/nodes captured during
      * lexing/parsing of text.

package/transform/compiler/src/render3/partial/api.js

@@ -15,4 +15,4 @@ var FactoryTarget;
     FactoryTarget[FactoryTarget["Injectable"] = 2] = "Injectable";
     FactoryTarget[FactoryTarget["Pipe"] = 3] = "Pipe";
     FactoryTarget[FactoryTarget["NgModule"] = 4] = "NgModule";
-})(FactoryTarget = exports.FactoryTarget || (exports.FactoryTarget = {}));
+})(FactoryTarget || (exports.FactoryTarget = FactoryTarget = {}));

package/transform/compiler/src/render3/r3_factory.d.ts

@@ -12,14 +12,6 @@ export interface R3ConstructorFactoryMetadata {
      * An expression representing the interface type being constructed.
      */
     type: R3Reference;
-    /**
-     * An expression representing the constructor type, intended for use within a class definition
-     * itself.
-     *
-     * This can differ from the outer `type` if the class is being compiled by ngcc and is inside
-     * an IIFE structure that uses a different name internally.
-     */
-    internalType: o.Expression;
     /** Number of arguments for the `type`. */
     typeArgumentCount: number;
     /**