@angular-eslint/bundled-angular-compiler 19.1.1-alpha.0 → 19.1.1-alpha.2

package/dist/index.js

@@ -141,11 +141,15 @@ __export(index_exports, {
   SplitInterpolation: () => SplitInterpolation,
   Statement: () => Statement,
   StmtModifier: () => StmtModifier,
+  StringToken: () => StringToken,
+  StringTokenKind: () => StringTokenKind,
   TagContentType: () => TagContentType,
-  TaggedTemplateExpr: () => TaggedTemplateExpr,
+  TaggedTemplateLiteralExpr: () => TaggedTemplateLiteralExpr,
   TemplateBindingParseResult: () => TemplateBindingParseResult,
   TemplateLiteral: () => TemplateLiteral,
   TemplateLiteralElement: () => TemplateLiteralElement,
+  TemplateLiteralElementExpr: () => TemplateLiteralElementExpr,
+  TemplateLiteralExpr: () => TemplateLiteralExpr,
   Text: () => Text,
   ThisReceiver: () => ThisReceiver,
   TmplAstBlockNode: () => BlockNode,
@@ -265,7 +269,7 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../../node_modules/.pnpm/@angular+compiler@19.1.5/node_modules/@angular/compiler/fesm2022/compiler.mjs
+// ../../node_modules/.pnpm/@angular+compiler@19.2.0/node_modules/@angular/compiler/fesm2022/compiler.mjs
 var _SELECTOR_REGEXP = new RegExp(
   `(\\:not\\()|(([\\.\\#]?)[-\\w]+)|(?:\\[([-.\\w*\\\\$]+)(?:=(["']?)([^\\]"']*)\\5)?\\])|(\\))|(\\s*,\\s*)`,
   // 8: ","
@@ -1432,9 +1436,9 @@ var InvokeFunctionExpr = class _InvokeFunctionExpr extends Expression {
     return new _InvokeFunctionExpr(this.fn.clone(), this.args.map((arg) => arg.clone()), this.type, this.sourceSpan, this.pure);
   }
 };
-var TaggedTemplateExpr = class _TaggedTemplateExpr extends Expression {
+var TaggedTemplateLiteralExpr = class _TaggedTemplateLiteralExpr extends Expression {
   static {
-    __name(this, "TaggedTemplateExpr");
+    __name(this, "TaggedTemplateLiteralExpr");
   }
   tag;
   template;
@@ -1444,16 +1448,16 @@ var TaggedTemplateExpr = class _TaggedTemplateExpr extends Expression {
     this.template = template2;
   }
   isEquivalent(e) {
-    return e instanceof _TaggedTemplateExpr && this.tag.isEquivalent(e.tag) && areAllEquivalentPredicate(this.template.elements, e.template.elements, (a, b) => a.text === b.text) && areAllEquivalent(this.template.expressions, e.template.expressions);
+    return e instanceof _TaggedTemplateLiteralExpr && this.tag.isEquivalent(e.tag) && this.template.isEquivalent(e.template);
   }
   isConstant() {
     return false;
   }
   visitExpression(visitor, context) {
-    return visitor.visitTaggedTemplateExpr(this, context);
+    return visitor.visitTaggedTemplateLiteralExpr(this, context);
   }
   clone() {
-    return new _TaggedTemplateExpr(this.tag.clone(), this.template.clone(), this.type, this.sourceSpan);
+    return new _TaggedTemplateLiteralExpr(this.tag.clone(), this.template.clone(), this.type, this.sourceSpan);
   }
 };
 var InstantiateExpr = class _InstantiateExpr extends Expression {
@@ -1502,34 +1506,52 @@ var LiteralExpr = class _LiteralExpr extends Expression {
     return new _LiteralExpr(this.value, this.type, this.sourceSpan);
   }
 };
-var TemplateLiteral = class _TemplateLiteral {
+var TemplateLiteralExpr = class _TemplateLiteralExpr extends Expression {
   static {
-    __name(this, "TemplateLiteral");
+    __name(this, "TemplateLiteralExpr");
   }
   elements;
   expressions;
-  constructor(elements, expressions) {
+  constructor(elements, expressions, sourceSpan) {
+    super(null, sourceSpan);
     this.elements = elements;
     this.expressions = expressions;
   }
+  isEquivalent(e) {
+    return e instanceof _TemplateLiteralExpr && areAllEquivalentPredicate(this.elements, e.elements, (a, b) => a.text === b.text) && areAllEquivalent(this.expressions, e.expressions);
+  }
+  isConstant() {
+    return false;
+  }
+  visitExpression(visitor, context) {
+    return visitor.visitTemplateLiteralExpr(this, context);
+  }
   clone() {
-    return new _TemplateLiteral(this.elements.map((el) => el.clone()), this.expressions.map((expr) => expr.clone()));
+    return new _TemplateLiteralExpr(this.elements.map((el) => el.clone()), this.expressions.map((expr) => expr.clone()));
   }
 };
-var TemplateLiteralElement = class _TemplateLiteralElement {
+var TemplateLiteralElementExpr = class _TemplateLiteralElementExpr extends Expression {
   static {
-    __name(this, "TemplateLiteralElement");
+    __name(this, "TemplateLiteralElementExpr");
   }
   text;
-  sourceSpan;
   rawText;
   constructor(text2, sourceSpan, rawText) {
+    super(STRING_TYPE, sourceSpan);
     this.text = text2;
-    this.sourceSpan = sourceSpan;
     this.rawText = rawText ?? sourceSpan?.toString() ?? escapeForTemplateLiteral(escapeSlashes(text2));
   }
+  visitExpression(visitor, context) {
+    return visitor.visitTemplateLiteralElementExpr(this, context);
+  }
+  isEquivalent(e) {
+    return e instanceof _TemplateLiteralElementExpr && e.text === this.text && e.rawText === this.rawText;
+  }
+  isConstant() {
+    return true;
+  }
   clone() {
-    return new _TemplateLiteralElement(this.text, this.sourceSpan, this.rawText);
+    return new _TemplateLiteralElementExpr(this.text, this.sourceSpan, this.rawText);
   }
 };
 var LiteralPiece = class {
@@ -2281,9 +2303,9 @@ var RecursiveAstVisitor$1 = class {
     this.visitAllExpressions(ast.args, context);
     return this.visitExpression(ast, context);
   }
-  visitTaggedTemplateExpr(ast, context) {
+  visitTaggedTemplateLiteralExpr(ast, context) {
     ast.tag.visitExpression(this, context);
-    this.visitAllExpressions(ast.template.expressions, context);
+    ast.template.visitExpression(this, context);
     return this.visitExpression(ast, context);
   }
   visitInstantiateExpr(ast, context) {
@@ -2355,6 +2377,14 @@ var RecursiveAstVisitor$1 = class {
     this.visitAllExpressions(ast.parts, context);
     return this.visitExpression(ast, context);
   }
+  visitTemplateLiteralExpr(ast, context) {
+    this.visitAllExpressions(ast.elements, context);
+    this.visitAllExpressions(ast.expressions, context);
+    return this.visitExpression(ast, context);
+  }
+  visitTemplateLiteralElementExpr(ast, context) {
+    return this.visitExpression(ast, context);
+  }
   visitAllExpressions(exprs, context) {
     exprs.forEach((expr) => expr.visitExpression(this, context));
   }
@@ -2453,7 +2483,7 @@ function ifStmt(condition, thenClause, elseClause, sourceSpan, leadingComments)
 }
 __name(ifStmt, "ifStmt");
 function taggedTemplate(tag, template2, type, sourceSpan) {
-  return new TaggedTemplateExpr(tag, template2, type, sourceSpan);
+  return new TaggedTemplateLiteralExpr(tag, template2, type, sourceSpan);
 }
 __name(taggedTemplate, "taggedTemplate");
 function literal(value, type, sourceSpan) {
@@ -2536,11 +2566,11 @@ var output_ast = /* @__PURE__ */ Object.freeze({
   WriteKeyExpr,
   WritePropExpr,
   InvokeFunctionExpr,
-  TaggedTemplateExpr,
+  TaggedTemplateLiteralExpr,
   InstantiateExpr,
   LiteralExpr,
-  TemplateLiteral,
-  TemplateLiteralElement,
+  TemplateLiteralExpr,
+  TemplateLiteralElementExpr,
   LiteralPiece,
   PlaceholderPiece,
   LocalizedString,
@@ -3275,10 +3305,6 @@ var Identifiers = class {
     name: "\u0275\u0275HostDirectivesFeature",
     moduleName: CORE
   };
-  static InputTransformsFeatureFeature = {
-    name: "\u0275\u0275InputTransformsFeature",
-    moduleName: CORE
-  };
   static ExternalStylesFeature = {
     name: "\u0275\u0275ExternalStylesFeature",
     moduleName: CORE
@@ -3819,16 +3845,26 @@ var AbstractEmitterVisitor = class {
     ctx.print(expr, `)`);
     return null;
   }
-  visitTaggedTemplateExpr(expr, ctx) {
+  visitTaggedTemplateLiteralExpr(expr, ctx) {
     expr.tag.visitExpression(this, ctx);
-    ctx.print(expr, "`" + expr.template.elements[0].rawText);
-    for (let i = 1; i < expr.template.elements.length; i++) {
-      ctx.print(expr, "${");
-      expr.template.expressions[i - 1].visitExpression(this, ctx);
-      ctx.print(expr, `}${expr.template.elements[i].rawText}`);
+    expr.template.visitExpression(this, ctx);
+    return null;
+  }
+  visitTemplateLiteralExpr(expr, ctx) {
+    ctx.print(expr, "`");
+    for (let i = 0; i < expr.elements.length; i++) {
+      expr.elements[i].visitExpression(this, ctx);
+      const expression = i < expr.expressions.length ? expr.expressions[i] : null;
+      if (expression !== null) {
+        ctx.print(expression, "${");
+        expression.visitExpression(this, ctx);
+        ctx.print(expression, "}");
+      }
     }
     ctx.print(expr, "`");
-    return null;
+  }
+  visitTemplateLiteralElementExpr(expr, ctx) {
+    ctx.print(expr, expr.rawText);
   }
   visitWrappedNodeExpr(ast, ctx) {
     throw new Error("Abstract emitter cannot visit WrappedNodeExpr.");
@@ -4695,6 +4731,34 @@ var SafeCall = class extends AST {
     return visitor.visitSafeCall(this, context);
   }
 };
+var TemplateLiteral = class extends AST {
+  static {
+    __name(this, "TemplateLiteral");
+  }
+  elements;
+  expressions;
+  constructor(span, sourceSpan, elements, expressions) {
+    super(span, sourceSpan);
+    this.elements = elements;
+    this.expressions = expressions;
+  }
+  visit(visitor, context) {
+    return visitor.visitTemplateLiteral(this, context);
+  }
+};
+var TemplateLiteralElement = class extends AST {
+  static {
+    __name(this, "TemplateLiteralElement");
+  }
+  text;
+  constructor(span, sourceSpan, text2) {
+    super(span, sourceSpan);
+    this.text = text2;
+  }
+  visit(visitor, context) {
+    return visitor.visitTemplateLiteralElement(this, context);
+  }
+};
 var AbsoluteSourceSpan = class {
   static {
     __name(this, "AbsoluteSourceSpan");
@@ -4853,6 +4917,17 @@ var RecursiveAstVisitor = class {
     this.visit(ast.receiver, context);
     this.visitAll(ast.args, context);
   }
+  visitTemplateLiteral(ast, context) {
+    for (let i = 0; i < ast.elements.length; i++) {
+      this.visit(ast.elements[i], context);
+      const expression = i < ast.expressions.length ? ast.expressions[i] : null;
+      if (expression !== null) {
+        this.visit(expression, context);
+      }
+    }
+  }
+  visitTemplateLiteralElement(ast, context) {
+  }
   // This is not part of the AstVisitor interface, just a helper method
   visitAll(asts, context) {
     for (const ast of asts) {
@@ -6979,7 +7054,7 @@ var AbstractJsEmitterVisitor = class extends AbstractEmitterVisitor {
     ctx.println(stmt, `;`);
     return null;
   }
-  visitTaggedTemplateExpr(ast, ctx) {
+  visitTaggedTemplateLiteralExpr(ast, ctx) {
     const elements = ast.template.elements;
     ast.tag.visitExpression(this, ctx);
     ctx.print(ast, `(${makeTemplateObjectPolyfill}(`);
@@ -6992,6 +7067,23 @@ var AbstractJsEmitterVisitor = class extends AbstractEmitterVisitor {
     ctx.print(ast, ")");
     return null;
   }
+  visitTemplateLiteralExpr(expr, ctx) {
+    ctx.print(expr, "`");
+    for (let i = 0; i < expr.elements.length; i++) {
+      expr.elements[i].visitExpression(this, ctx);
+      const expression = i < expr.expressions.length ? expr.expressions[i] : null;
+      if (expression !== null) {
+        ctx.print(expression, "${");
+        expression.visitExpression(this, ctx);
+        ctx.print(expression, "}");
+      }
+    }
+    ctx.print(expr, "`");
+  }
+  visitTemplateLiteralElementExpr(expr, ctx) {
+    ctx.print(expr, expr.rawText);
+    return null;
+  }
   visitFunctionExpr(ast, ctx) {
     ctx.print(ast, `function${ast.name ? " " + ast.name : ""}(`);
     this._visitParams(ast.params, ctx);
@@ -9602,7 +9694,13 @@ function transformExpressionsInOp(op, transform2, flags) {
       op.trustedValueFn = op.trustedValueFn && transformExpressionsInExpression(op.trustedValueFn, transform2, flags);
       break;
     case OpKind.RepeaterCreate:
-      op.track = transformExpressionsInExpression(op.track, transform2, flags);
+      if (op.trackByOps === null) {
+        op.track = transformExpressionsInExpression(op.track, transform2, flags);
+      } else {
+        for (const innerOp of op.trackByOps) {
+          transformExpressionsInOp(innerOp, transform2, flags | VisitorContextFlag.InChildOperation);
+        }
+      }
       if (op.trackByFn !== null) {
         op.trackByFn = transformExpressionsInExpression(op.trackByFn, transform2, flags);
       }
@@ -9717,7 +9815,7 @@ function transformExpressionsInExpression(expr, transform2, flags) {
     }
   } else if (expr instanceof NotExpr) {
     expr.condition = transformExpressionsInExpression(expr.condition, transform2, flags);
-  } else if (expr instanceof TaggedTemplateExpr) {
+  } else if (expr instanceof TaggedTemplateLiteralExpr) {
     expr.tag = transformExpressionsInExpression(expr.tag, transform2, flags);
     expr.template.expressions = expr.template.expressions.map((e) => transformExpressionsInExpression(e, transform2, flags));
   } else if (expr instanceof ArrowFunctionExpr) {
@@ -9729,6 +9827,10 @@ function transformExpressionsInExpression(expr, transform2, flags) {
       expr.body = transformExpressionsInExpression(expr.body, transform2, flags);
     }
   } else if (expr instanceof WrappedNodeExpr) {
+  } else if (expr instanceof TemplateLiteralExpr) {
+    for (let i = 0; i < expr.expressions.length; i++) {
+      expr.expressions[i] = transformExpressionsInExpression(expr.expressions[i], transform2, flags);
+    }
   } else if (expr instanceof ReadVarExpr || expr instanceof ExternalExpr || expr instanceof LiteralExpr) {
   } else {
     throw new Error(`Unhandled expression kind: ${expr.constructor.name}`);
@@ -10062,6 +10164,7 @@ function createRepeaterCreateOp(primaryView, emptyView, tag, track, varNames, em
     emptyView,
     track,
     trackByFn: null,
+    trackByOps: null,
     tag,
     emptyTag,
     emptyAttributes: null,
@@ -10539,6 +10642,10 @@ var CompilationUnit = class {
         for (const listenerOp of op.handlerOps) {
           yield listenerOp;
         }
+      } else if (op.kind === OpKind.RepeaterCreate && op.trackByOps !== null) {
+        for (const trackOp of op.trackByOps) {
+          yield trackOp;
+        }
       }
     }
     for (const op of this.update) {
@@ -11216,7 +11323,7 @@ var ElementAttributes = class {
         if (!isStringLiteral(value)) {
           throw Error("AssertionError: extracted attribute value should be string literal");
         }
-        array.push(taggedTemplate(trustedValueFn, new TemplateLiteral([new TemplateLiteralElement(value.value)], []), void 0, value.sourceSpan));
+        array.push(taggedTemplate(trustedValueFn, new TemplateLiteralExpr([new TemplateLiteralElementExpr(value.value)], []), void 0, value.sourceSpan));
       } else {
         array.push(value);
       }
@@ -11968,6 +12075,9 @@ function recursivelyProcessView(view, parentScope) {
         if (op.emptyView) {
           recursivelyProcessView(view.job.views.get(op.emptyView), scope);
         }
+        if (op.trackByOps !== null) {
+          op.trackByOps.prepend(generateVariablesInScopeForView(view, scope, false));
+        }
         break;
       case OpKind.Listener:
       case OpKind.TwoWayListener:
@@ -16342,6 +16452,12 @@ var TokenType;
   TokenType2[TokenType2["Number"] = 6] = "Number";
   TokenType2[TokenType2["Error"] = 7] = "Error";
 })(TokenType || (TokenType = {}));
+var StringTokenKind;
+(function(StringTokenKind2) {
+  StringTokenKind2[StringTokenKind2["Plain"] = 0] = "Plain";
+  StringTokenKind2[StringTokenKind2["TemplateLiteralPart"] = 1] = "TemplateLiteralPart";
+  StringTokenKind2[StringTokenKind2["TemplateLiteralEnd"] = 2] = "TemplateLiteralEnd";
+})(StringTokenKind || (StringTokenKind = {}));
 var KEYWORDS = [
   "var",
   "let",
@@ -16360,14 +16476,7 @@ var Lexer = class {
     __name(this, "Lexer");
   }
   tokenize(text2) {
-    const scanner = new _Scanner(text2);
-    const tokens = [];
-    let token = scanner.scanToken();
-    while (token != null) {
-      tokens.push(token);
-      token = scanner.scanToken();
-    }
-    return tokens;
+    return new _Scanner(text2).scan();
   }
 };
 var Token = class {
@@ -16387,55 +16496,67 @@ var Token = class {
     this.strValue = strValue;
   }
   isCharacter(code) {
-    return this.type == TokenType.Character && this.numValue == code;
+    return this.type === TokenType.Character && this.numValue === code;
   }
   isNumber() {
-    return this.type == TokenType.Number;
+    return this.type === TokenType.Number;
   }
   isString() {
-    return this.type == TokenType.String;
+    return this.type === TokenType.String;
   }
   isOperator(operator) {
-    return this.type == TokenType.Operator && this.strValue == operator;
+    return this.type === TokenType.Operator && this.strValue === operator;
   }
   isIdentifier() {
-    return this.type == TokenType.Identifier;
+    return this.type === TokenType.Identifier;
   }
   isPrivateIdentifier() {
-    return this.type == TokenType.PrivateIdentifier;
+    return this.type === TokenType.PrivateIdentifier;
   }
   isKeyword() {
-    return this.type == TokenType.Keyword;
+    return this.type === TokenType.Keyword;
   }
   isKeywordLet() {
-    return this.type == TokenType.Keyword && this.strValue == "let";
+    return this.type === TokenType.Keyword && this.strValue === "let";
   }
   isKeywordAs() {
-    return this.type == TokenType.Keyword && this.strValue == "as";
+    return this.type === TokenType.Keyword && this.strValue === "as";
   }
   isKeywordNull() {
-    return this.type == TokenType.Keyword && this.strValue == "null";
+    return this.type === TokenType.Keyword && this.strValue === "null";
   }
   isKeywordUndefined() {
-    return this.type == TokenType.Keyword && this.strValue == "undefined";
+    return this.type === TokenType.Keyword && this.strValue === "undefined";
   }
   isKeywordTrue() {
-    return this.type == TokenType.Keyword && this.strValue == "true";
+    return this.type === TokenType.Keyword && this.strValue === "true";
   }
   isKeywordFalse() {
-    return this.type == TokenType.Keyword && this.strValue == "false";
+    return this.type === TokenType.Keyword && this.strValue === "false";
   }
   isKeywordThis() {
-    return this.type == TokenType.Keyword && this.strValue == "this";
+    return this.type === TokenType.Keyword && this.strValue === "this";
   }
   isKeywordTypeof() {
     return this.type === TokenType.Keyword && this.strValue === "typeof";
   }
   isError() {
-    return this.type == TokenType.Error;
+    return this.type === TokenType.Error;
   }
   toNumber() {
-    return this.type == TokenType.Number ? this.numValue : -1;
+    return this.type === TokenType.Number ? this.numValue : -1;
+  }
+  isTemplateLiteralPart() {
+    return this.isString() && this.kind === StringTokenKind.TemplateLiteralPart;
+  }
+  isTemplateLiteralEnd() {
+    return this.isString() && this.kind === StringTokenKind.TemplateLiteralEnd;
+  }
+  isTemplateLiteralInterpolationStart() {
+    return this.isOperator("${");
+  }
+  isTemplateLiteralInterpolationEnd() {
+    return this.isOperator("}");
   }
   toString() {
     switch (this.type) {
@@ -16454,6 +16575,16 @@ var Token = class {
     }
   }
 };
+var StringToken = class extends Token {
+  static {
+    __name(this, "StringToken");
+  }
+  kind;
+  constructor(index, end, strValue, kind) {
+    super(index, end, TokenType.String, 0, strValue);
+    this.kind = kind;
+  }
+};
 function newCharacterToken(index, end, code) {
   return new Token(index, end, TokenType.Character, code, String.fromCharCode(code));
 }
@@ -16474,10 +16605,6 @@ function newOperatorToken(index, end, text2) {
   return new Token(index, end, TokenType.Operator, 0, text2);
 }
 __name(newOperatorToken, "newOperatorToken");
-function newStringToken(index, end, text2) {
-  return new Token(index, end, TokenType.String, 0, text2);
-}
-__name(newStringToken, "newStringToken");
 function newNumberToken(index, end, n) {
   return new Token(index, end, TokenType.Number, n, "");
 }
@@ -16492,20 +16619,33 @@ var _Scanner = class {
     __name(this, "_Scanner");
   }
   input;
+  tokens = [];
   length;
   peek = 0;
   index = -1;
+  literalInterpolationDepth = 0;
+  braceDepth = 0;
   constructor(input) {
     this.input = input;
     this.length = input.length;
     this.advance();
   }
+  scan() {
+    let token = this.scanToken();
+    while (token !== null) {
+      this.tokens.push(token);
+      token = this.scanToken();
+    }
+    return this.tokens;
+  }
   advance() {
     this.peek = ++this.index >= this.length ? $EOF : this.input.charCodeAt(this.index);
   }
   scanToken() {
-    const input = this.input, length = this.length;
-    let peek = this.peek, index = this.index;
+    const input = this.input;
+    const length = this.length;
+    let peek = this.peek;
+    let index = this.index;
     while (peek <= $SPACE) {
       if (++index >= length) {
         peek = $EOF;
@@ -16519,10 +16659,12 @@ var _Scanner = class {
     if (index >= length) {
       return null;
     }
-    if (isIdentifierStart(peek))
+    if (isIdentifierStart(peek)) {
       return this.scanIdentifier();
-    if (isDigit(peek))
+    }
+    if (isDigit(peek)) {
       return this.scanNumber(index);
+    }
     const start = index;
     switch (peek) {
       case $PERIOD:
@@ -16530,17 +16672,22 @@ var _Scanner = class {
         return isDigit(this.peek) ? this.scanNumber(start) : newCharacterToken(start, this.index, $PERIOD);
       case $LPAREN:
       case $RPAREN:
-      case $LBRACE:
-      case $RBRACE:
       case $LBRACKET:
       case $RBRACKET:
       case $COMMA:
       case $COLON:
       case $SEMICOLON:
         return this.scanCharacter(start, peek);
+      case $LBRACE:
+        return this.scanOpenBrace(start, peek);
+      case $RBRACE:
+        return this.scanCloseBrace(start, peek);
       case $SQ:
       case $DQ:
         return this.scanString();
+      case $BT:
+        this.advance();
+        return this.scanTemplateLiteralPart(start);
       case $HASH:
         return this.scanPrivateIdentifier();
       case $PLUS:
@@ -16578,6 +16725,21 @@ var _Scanner = class {
     this.advance();
     return newOperatorToken(start, this.index, str);
   }
+  scanOpenBrace(start, code) {
+    this.braceDepth++;
+    this.advance();
+    return newCharacterToken(start, this.index, code);
+  }
+  scanCloseBrace(start, code) {
+    this.advance();
+    if (this.braceDepth === 0 && this.literalInterpolationDepth > 0) {
+      this.literalInterpolationDepth--;
+      this.tokens.push(newOperatorToken(start, this.index, "}"));
+      return this.scanTemplateLiteralPart(this.index);
+    }
+    this.braceDepth--;
+    return newCharacterToken(start, this.index, code);
+  }
   /**
    * Tokenize a 2/3 char long operator
    *
@@ -16662,24 +16824,11 @@ var _Scanner = class {
     const input = this.input;
     while (this.peek != quote) {
       if (this.peek == $BACKSLASH) {
-        buffer += input.substring(marker, this.index);
-        let unescapedCode;
-        this.advance();
-        if (this.peek == $u) {
-          const hex = input.substring(this.index + 1, this.index + 5);
-          if (/^[0-9a-f]+$/i.test(hex)) {
-            unescapedCode = parseInt(hex, 16);
-          } else {
-            return this.error(`Invalid unicode escape [\\u${hex}]`, 0);
-          }
-          for (let i = 0; i < 5; i++) {
-            this.advance();
-          }
-        } else {
-          unescapedCode = unescape(this.peek);
-          this.advance();
+        const result = this.scanStringBackslash(buffer, marker);
+        if (typeof result !== "string") {
+          return result;
         }
-        buffer += String.fromCharCode(unescapedCode);
+        buffer = result;
         marker = this.index;
       } else if (this.peek == $EOF) {
         return this.error("Unterminated quote", 0);
@@ -16689,7 +16838,7 @@ var _Scanner = class {
     }
     const last = input.substring(marker, this.index);
     this.advance();
-    return newStringToken(start, this.index, buffer + last);
+    return new StringToken(start, this.index, buffer + last, StringTokenKind.Plain);
   }
   scanQuestion(start) {
     this.advance();
@@ -16700,10 +16849,61 @@ var _Scanner = class {
     }
     return newOperatorToken(start, this.index, str);
   }
+  scanTemplateLiteralPart(start) {
+    let buffer = "";
+    let marker = this.index;
+    while (this.peek !== $BT) {
+      if (this.peek === $BACKSLASH) {
+        const result = this.scanStringBackslash(buffer, marker);
+        if (typeof result !== "string") {
+          return result;
+        }
+        buffer = result;
+        marker = this.index;
+      } else if (this.peek === $$) {
+        const dollar = this.index;
+        this.advance();
+        if (this.peek === $LBRACE) {
+          this.literalInterpolationDepth++;
+          this.tokens.push(new StringToken(start, dollar, buffer + this.input.substring(marker, dollar), StringTokenKind.TemplateLiteralPart));
+          this.advance();
+          return newOperatorToken(dollar, this.index, this.input.substring(dollar, this.index));
+        }
+      } else if (this.peek === $EOF) {
+        return this.error("Unterminated template literal", 0);
+      } else {
+        this.advance();
+      }
+    }
+    const last = this.input.substring(marker, this.index);
+    this.advance();
+    return new StringToken(start, this.index, buffer + last, StringTokenKind.TemplateLiteralEnd);
+  }
   error(message, offset) {
     const position = this.index + offset;
     return newErrorToken(position, this.index, `Lexer Error: ${message} at column ${position} in expression [${this.input}]`);
   }
+  scanStringBackslash(buffer, marker) {
+    buffer += this.input.substring(marker, this.index);
+    let unescapedCode;
+    this.advance();
+    if (this.peek === $u) {
+      const hex = this.input.substring(this.index + 1, this.index + 5);
+      if (/^[0-9a-f]+$/i.test(hex)) {
+        unescapedCode = parseInt(hex, 16);
+      } else {
+        return this.error(`Invalid unicode escape [\\u${hex}]`, 0);
+      }
+      for (let i = 0; i < 5; i++) {
+        this.advance();
+      }
+    } else {
+      unescapedCode = unescape(this.peek);
+      this.advance();
+    }
+    buffer += String.fromCharCode(unescapedCode);
+    return buffer;
+  }
 };
 function isIdentifierStart(code) {
   return $a <= code && code <= $z || $A <= code && code <= $Z || code == $_ || code == $$;
@@ -17469,7 +17669,11 @@ var _ParseAST = class {
       const value = this.next.toNumber();
       this.advance();
       return new LiteralPrimitive(this.span(start), this.sourceSpan(start), value);
-    } else if (this.next.isString()) {
+    } else if (this.next.isTemplateLiteralEnd()) {
+      return this.parseNoInterpolationTemplateLiteral(start);
+    } else if (this.next.isTemplateLiteralPart()) {
+      return this.parseTemplateLiteral();
+    } else if (this.next.isString() && this.next.kind === StringTokenKind.Plain) {
       const literalValue = this.next.toString();
       this.advance();
       return new LiteralPrimitive(this.span(start), this.sourceSpan(start), literalValue);
@@ -17758,6 +17962,39 @@ var _ParseAST = class {
     const sourceSpan = new AbsoluteSourceSpan(spanStart, this.currentAbsoluteOffset);
     return new VariableBinding(sourceSpan, key, value);
   }
+  parseNoInterpolationTemplateLiteral(start) {
+    const text2 = this.next.strValue;
+    this.advance();
+    const span = this.span(start);
+    const sourceSpan = this.sourceSpan(start);
+    return new TemplateLiteral(span, sourceSpan, [new TemplateLiteralElement(span, sourceSpan, text2)], []);
+  }
+  parseTemplateLiteral() {
+    const start = this.inputIndex;
+    const elements = [];
+    const expressions = [];
+    while (this.next !== EOF) {
+      const token = this.next;
+      if (token.isTemplateLiteralPart() || token.isTemplateLiteralEnd()) {
+        elements.push(new TemplateLiteralElement(this.span(this.inputIndex), this.sourceSpan(this.inputIndex), token.strValue));
+        this.advance();
+        if (token.isTemplateLiteralEnd()) {
+          break;
+        }
+      } else if (token.isTemplateLiteralInterpolationStart()) {
+        this.advance();
+        const expression = this.parsePipe();
+        if (expression instanceof EmptyExpr$1) {
+          this.error("Template literal interpolation cannot be empty");
+        } else {
+          expressions.push(expression);
+        }
+      } else {
+        this.advance();
+      }
+    }
+    return new TemplateLiteral(this.span(start), this.sourceSpan(start), elements, expressions);
+  }
   /**
    * Consume the optional statement terminator: semicolon or comma.
    */
@@ -17952,6 +18189,20 @@ var SerializeExpressionVisitor = class {
   visitASTWithSource(ast, context) {
     return ast.ast.visit(this, context);
   }
+  visitTemplateLiteral(ast, context) {
+    let result = "";
+    for (let i = 0; i < ast.elements.length; i++) {
+      result += ast.elements[i].visit(this, context);
+      const expression = i < ast.expressions.length ? ast.expressions[i] : null;
+      if (expression !== null) {
+        result += "${" + expression.visit(this, context) + "}";
+      }
+    }
+    return "`" + result + "`";
+  }
+  visitTemplateLiteralElement(ast, context) {
+    return ast.text;
+  }
 };
 function zip(left, right) {
   if (left.length !== right.length)
@@ -21226,7 +21477,7 @@ function reifyCreateOperations(unit, ops) {
           emptyDecls = emptyView.decls;
           emptyVars = emptyView.vars;
         }
-        OpList.replace(op, repeaterCreate(op.handle.slot, repeaterView.fnName, op.decls, op.vars, op.tag, op.attributes, op.trackByFn, op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.emptyTag, op.emptyAttributes, op.wholeSourceSpan));
+        OpList.replace(op, repeaterCreate(op.handle.slot, repeaterView.fnName, op.decls, op.vars, op.tag, op.attributes, reifyTrackBy(unit, op), op.usesComponentInstance, emptyViewFnName, emptyDecls, emptyVars, op.emptyTag, op.emptyAttributes, op.wholeSourceSpan));
         break;
       case OpKind.SourceLocation:
         const locationsLiteral = literalArr(op.locations.map(({ targetSlot, offset, line, column }) => {
@@ -21400,6 +21651,8 @@ function reifyIrExpression(expr) {
       return readContextLet(expr.targetSlot.slot);
     case ExpressionKind.StoreLet:
       return storeLet(expr.value, expr.sourceSpan);
+    case ExpressionKind.TrackContext:
+      return variable("this");
     default:
       throw new Error(`AssertionError: Unsupported reification of ir.Expression kind: ${ExpressionKind[expr.kind]}`);
   }
@@ -21421,6 +21674,29 @@ function reifyListenerHandler(unit, name, handlerOps, consumesDollarEvent) {
   return fn(params, handlerStmts, void 0, void 0, name);
 }
 __name(reifyListenerHandler, "reifyListenerHandler");
+function reifyTrackBy(unit, op) {
+  if (op.trackByFn !== null) {
+    return op.trackByFn;
+  }
+  const params = [new FnParam("$index"), new FnParam("$item")];
+  let fn$1;
+  if (op.trackByOps === null) {
+    fn$1 = op.usesComponentInstance ? fn(params, [new ReturnStatement(op.track)]) : arrowFn(params, op.track);
+  } else {
+    reifyUpdateOperations(unit, op.trackByOps);
+    const statements = [];
+    for (const trackOp of op.trackByOps) {
+      if (trackOp.kind !== OpKind.Statement) {
+        throw new Error(`AssertionError: expected reified statements, but found op ${OpKind[trackOp.kind]}`);
+      }
+      statements.push(trackOp.statement);
+    }
+    fn$1 = op.usesComponentInstance || statements.length !== 1 || !(statements[0] instanceof ReturnStatement) ? fn(params, statements) : arrowFn(params, statements[0].value);
+  }
+  op.trackByFn = unit.job.pool.getSharedFunctionReference(fn$1, "_forTrack");
+  return op.trackByFn;
+}
+__name(reifyTrackBy, "reifyTrackBy");
 function removeEmptyBindings(job) {
   for (const unit of job.units) {
     for (const op of unit.update) {
@@ -21500,6 +21776,11 @@ function processLexicalScope$1(view, ops) {
       case OpKind.TwoWayListener:
         processLexicalScope$1(view, op.handlerOps);
         break;
+      case OpKind.RepeaterCreate:
+        if (op.trackByOps !== null) {
+          processLexicalScope$1(view, op.trackByOps);
+        }
+        break;
     }
   }
   if (view === view.job.root) {
@@ -21821,6 +22102,11 @@ function processLexicalScope(unit, ops, savedView) {
       case OpKind.TwoWayListener:
         processLexicalScope(unit, op.handlerOps, savedView);
         break;
+      case OpKind.RepeaterCreate:
+        if (op.trackByOps !== null) {
+          processLexicalScope(unit, op.trackByOps, savedView);
+        }
+        break;
     }
   }
   for (const op of ops) {
@@ -22091,6 +22377,8 @@ function generateTemporaries(ops) {
     opCount++;
     if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
       op.handlerOps.prepend(generateTemporaries(op.handlerOps));
+    } else if (op.kind === OpKind.RepeaterCreate && op.trackByOps !== null) {
+      op.trackByOps.prepend(generateTemporaries(op.trackByOps));
     }
   }
   return generatedStatements;
@@ -22104,38 +22392,6 @@ function assignName(names, expr) {
   expr.name = name;
 }
 __name(assignName, "assignName");
-function generateTrackFns(job) {
-  for (const unit of job.units) {
-    for (const op of unit.create) {
-      if (op.kind !== OpKind.RepeaterCreate) {
-        continue;
-      }
-      if (op.trackByFn !== null) {
-        continue;
-      }
-      let usesComponentContext = false;
-      op.track = transformExpressionsInExpression(op.track, (expr) => {
-        if (expr instanceof PipeBindingExpr || expr instanceof PipeBindingVariadicExpr) {
-          throw new Error(`Illegal State: Pipes are not allowed in this context`);
-        }
-        if (expr instanceof TrackContextExpr) {
-          usesComponentContext = true;
-          return variable("this");
-        }
-        return expr;
-      }, VisitorContextFlag.None);
-      let fn2;
-      const fnParams = [new FnParam("$index"), new FnParam("$item")];
-      if (usesComponentContext) {
-        fn2 = new FunctionExpr(fnParams, [new ReturnStatement(op.track)]);
-      } else {
-        fn2 = arrowFn(fnParams, op.track);
-      }
-      op.trackByFn = job.pool.getSharedFunctionReference(fn2, "_forTrack");
-    }
-  }
-}
-__name(generateTrackFns, "generateTrackFns");
 function optimizeTrackFns(job) {
   for (const unit of job.units) {
     for (const op of unit.create) {
@@ -22156,12 +22412,17 @@ function optimizeTrackFns(job) {
         }
       } else {
         op.track = transformExpressionsInExpression(op.track, (expr) => {
-          if (expr instanceof ContextExpr) {
+          if (expr instanceof PipeBindingExpr || expr instanceof PipeBindingVariadicExpr) {
+            throw new Error(`Illegal State: Pipes are not allowed in this context`);
+          } else if (expr instanceof ContextExpr) {
             op.usesComponentInstance = true;
             return new TrackContextExpr(expr.view);
           }
           return expr;
         }, VisitorContextFlag.None);
+        const trackOpList = new OpList();
+        trackOpList.push(createStatementOp(new ReturnStatement(op.track, op.track.sourceSpan)));
+        op.trackByOps = trackOpList;
       }
     }
   }
@@ -22328,6 +22589,8 @@ function optimizeVariables(job) {
     for (const op of unit.create) {
       if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
         inlineAlwaysInlineVariables(op.handlerOps);
+      } else if (op.kind === OpKind.RepeaterCreate && op.trackByOps !== null) {
+        inlineAlwaysInlineVariables(op.trackByOps);
       }
     }
     optimizeVariablesInOpList(unit.create, job.compatibility);
@@ -22335,6 +22598,8 @@ function optimizeVariables(job) {
     for (const op of unit.create) {
       if (op.kind === OpKind.Listener || op.kind === OpKind.TwoWayListener) {
         optimizeVariablesInOpList(op.handlerOps, job.compatibility);
+      } else if (op.kind === OpKind.RepeaterCreate && op.trackByOps !== null) {
+        optimizeVariablesInOpList(op.trackByOps, job.compatibility);
       }
     }
   }
@@ -22733,7 +22998,6 @@ var phases = [
   { kind: CompilationJobKind.Tmpl, fn: resolveI18nElementPlaceholders },
   { kind: CompilationJobKind.Tmpl, fn: resolveI18nExpressionPlaceholders },
   { kind: CompilationJobKind.Tmpl, fn: extractI18nMessages },
-  { kind: CompilationJobKind.Tmpl, fn: generateTrackFns },
   { kind: CompilationJobKind.Tmpl, fn: collectI18nConsts },
   { kind: CompilationJobKind.Tmpl, fn: collectConstExpressions },
   { kind: CompilationJobKind.Both, fn: collectElementConsts },
@@ -23425,6 +23689,10 @@ function convertAst(ast, job, baseSourceSpan) {
     return not(convertAst(ast.expression, job, baseSourceSpan), convertSourceSpan(ast.span, baseSourceSpan));
   } else if (ast instanceof TypeofExpression) {
     return typeofExpr(convertAst(ast.expression, job, baseSourceSpan));
+  } else if (ast instanceof TemplateLiteral) {
+    return new TemplateLiteralExpr(ast.elements.map((el) => {
+      return new TemplateLiteralElementExpr(el.text, convertSourceSpan(el.span, baseSourceSpan));
+    }), ast.expressions.map((expr) => convertAst(expr, job, baseSourceSpan)), convertSourceSpan(ast.span, baseSourceSpan));
   } else {
     throw new Error(`Unhandled expression type "${ast.constructor.name}" in file "${baseSourceSpan?.start.file.url}"`);
   }
@@ -25755,7 +26023,6 @@ function addFeatures(definitionMap, meta) {
   const features = [];
   const providers = meta.providers;
   const viewProviders = meta.viewProviders;
-  const inputKeys = Object.keys(meta.inputs);
   if (providers || viewProviders) {
     const args = [providers || new LiteralArrayExpr([])];
     if (viewProviders) {
@@ -25763,12 +26030,6 @@ function addFeatures(definitionMap, meta) {
     }
     features.push(importExpr(Identifiers.ProvidersFeature).callFn(args));
   }
-  for (const key of inputKeys) {
-    if (meta.inputs[key].transformFunction !== null) {
-      features.push(importExpr(Identifiers.InputTransformsFeatureFeature));
-      break;
-    }
-  }
   if (meta.hostDirectives?.length) {
     features.push(importExpr(Identifiers.HostDirectivesFeature).callFn([createHostDirectivesFeatureArg(meta.hostDirectives)]));
   }
@@ -27615,7 +27876,7 @@ function publishFacade(global) {
   ng.\u0275compilerFacade = new CompilerFacadeImpl();
 }
 __name(publishFacade, "publishFacade");
-var VERSION = new Version("19.1.5");
+var VERSION = new Version("19.2.0");
 var CompilerConfig = class {
   static {
     __name(this, "CompilerConfig");
@@ -29323,11 +29584,10 @@ function compileClassDebugInfo(debugInfo) {
 }
 __name(compileClassDebugInfo, "compileClassDebugInfo");
 function compileHmrInitializer(meta) {
-  const id = encodeURIComponent(`${meta.filePath}@${meta.className}`);
-  const urlPartial = `./@ng/component?c=${id}&t=`;
   const moduleName = "m";
   const dataName = "d";
   const timestampName = "t";
+  const idName = "id";
   const importCallbackName = `${meta.className}_HmrLoad`;
   const namespaces = meta.namespaceDependencies.map((dep) => {
     return new ExternalExpr({ moduleName: dep.moduleName, name: null });
@@ -29337,10 +29597,12 @@ function compileHmrInitializer(meta) {
     meta.type,
     defaultRead,
     literalArr(namespaces),
-    literalArr(meta.localDependencies.map((l) => l.runtimeRepresentation))
+    literalArr(meta.localDependencies.map((l) => l.runtimeRepresentation)),
+    variable("import").prop("meta"),
+    variable(idName)
   ]);
   const replaceCallback = arrowFn([new FnParam(moduleName)], defaultRead.and(replaceCall));
-  const urlValue = literal(urlPartial).plus(variable("encodeURIComponent").callFn([variable(timestampName)]));
+  const urlValue = literal(`./@ng/component?c=`).plus(variable(idName)).plus(literal("&t=")).plus(variable("encodeURIComponent").callFn([variable(timestampName)]));
   const urlBase = variable("import").prop("meta").prop("url");
   const urlHref = new InstantiateExpr(variable("URL"), [urlValue, urlBase]).prop("href");
   const importCallback = new DeclareFunctionStmt(importCallbackName, [new FnParam(timestampName)], [
@@ -29349,11 +29611,13 @@ function compileHmrInitializer(meta) {
     // programmatically avoid this warning in the future, this added comment can be removed here.
     new DynamicImportExpr(urlHref, null, "@vite-ignore").prop("then").callFn([replaceCallback]).toStmt()
   ], null, StmtModifier.Final);
-  const updateCallback = arrowFn([new FnParam(dataName)], variable(dataName).prop("id").identical(literal(id)).and(variable(importCallbackName).callFn([variable(dataName).prop("timestamp")])));
+  const updateCallback = arrowFn([new FnParam(dataName)], variable(dataName).prop("id").identical(variable(idName)).and(variable(importCallbackName).callFn([variable(dataName).prop("timestamp")])));
   const initialCall = variable(importCallbackName).callFn([variable("Date").prop("now").callFn([])]);
   const hotRead = variable("import").prop("meta").prop("hot");
   const hotListener = hotRead.clone().prop("on").callFn([literal("angular:component-update"), updateCallback]);
   return arrowFn([], [
+    // const id = <id>;
+    new DeclareVarStmt(idName, literal(encodeURIComponent(`${meta.filePath}@${meta.className}`)), null, StmtModifier.Final),
     // function Cmp_HmrLoad() {...}.
     importCallback,
     // ngDevMode && Cmp_HmrLoad(Date.now());
@@ -29390,7 +29654,7 @@ var MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION = "18.0.0";
 function compileDeclareClassMetadata(metadata) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$5));
-  definitionMap.set("version", literal("19.1.5"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -29409,7 +29673,7 @@ function compileComponentDeclareClassMetadata(metadata, dependencies) {
   callbackReturnDefinitionMap.set("ctorParameters", metadata.ctorParameters ?? literal(null));
   callbackReturnDefinitionMap.set("propDecorators", metadata.propDecorators ?? literal(null));
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_DEFER_SUPPORT_VERSION));
-  definitionMap.set("version", literal("19.1.5"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("resolveDeferredDeps", compileComponentMetadataAsyncResolver(dependencies));
@@ -29478,7 +29742,7 @@ function createDirectiveDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   const minVersion = getMinimumVersionForPartialOutput(meta);
   definitionMap.set("minVersion", literal(minVersion));
-  definitionMap.set("version", literal("19.1.5"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone !== void 0) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -29806,7 +30070,7 @@ var MINIMUM_PARTIAL_LINKER_VERSION$4 = "12.0.0";
 function compileDeclareFactoryFunction(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$4));
-  definitionMap.set("version", literal("19.1.5"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("deps", compileDependencies(meta.deps));
@@ -29829,7 +30093,7 @@ __name(compileDeclareInjectableFromMetadata, "compileDeclareInjectableFromMetada
 function createInjectableDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-  definitionMap.set("version", literal("19.1.5"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -29867,7 +30131,7 @@ __name(compileDeclareInjectorFromMetadata, "compileDeclareInjectorFromMetadata")
 function createInjectorDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-  definitionMap.set("version", literal("19.1.5"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -29891,7 +30155,7 @@ function createNgModuleDefinitionMap(meta) {
     throw new Error("Invalid path! Local compilation mode should not get into the partial compilation path");
   }
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION$1));
-  definitionMap.set("version", literal("19.1.5"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -29926,7 +30190,7 @@ __name(compileDeclarePipeFromMetadata, "compileDeclarePipeFromMetadata");
 function createPipeDefinitionMap(meta) {
   const definitionMap = new DefinitionMap();
   definitionMap.set("minVersion", literal(MINIMUM_PARTIAL_LINKER_VERSION));
-  definitionMap.set("version", literal("19.1.5"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone !== void 0) {
@@ -30062,11 +30326,15 @@ publishFacade(_global);
   SplitInterpolation,
   Statement,
   StmtModifier,
+  StringToken,
+  StringTokenKind,
   TagContentType,
-  TaggedTemplateExpr,
+  TaggedTemplateLiteralExpr,
   TemplateBindingParseResult,
   TemplateLiteral,
   TemplateLiteralElement,
+  TemplateLiteralElementExpr,
+  TemplateLiteralExpr,
   Text,
   ThisReceiver,
   TmplAstBlockNode,
@@ -30188,7 +30456,7 @@ publishFacade(_global);
 
 @angular/compiler/fesm2022/compiler.mjs:
   (**
-   * @license Angular v19.1.5
+   * @license Angular v19.2.0
    * (c) 2010-2024 Google LLC. https://angular.io/
    * License: MIT
    *)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/bundled-angular-compiler",
-  "version": "19.1.1-alpha.0",
+  "version": "19.1.1-alpha.2",
   "description": "A CJS bundled version of @angular/compiler",
   "license": "MIT",
   "main": "dist/index.js",