@angular-eslint/bundled-angular-compiler 19.1.1-alpha.1 → 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.7/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,
@@ -3815,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.");
@@ -4691,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");
@@ -4849,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) {
@@ -6975,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}(`);
@@ -6988,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);
@@ -9719,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) {
@@ -9731,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}`);
@@ -11223,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);
       }
@@ -16352,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",
@@ -16370,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 {
@@ -16397,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) {
@@ -16464,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));
 }
@@ -16484,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, "");
 }
@@ -16502,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;
@@ -16529,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:
@@ -16540,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:
@@ -16588,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
    *
@@ -16672,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);
@@ -16699,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();
@@ -16710,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 == $$;
@@ -17479,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);
@@ -17768,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.
    */
@@ -17962,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)
@@ -23448,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}"`);
   }
@@ -27631,7 +27876,7 @@ function publishFacade(global) {
   ng.\u0275compilerFacade = new CompilerFacadeImpl();
 }
 __name(publishFacade, "publishFacade");
-var VERSION = new Version("19.1.7");
+var VERSION = new Version("19.2.0");
 var CompilerConfig = class {
   static {
     __name(this, "CompilerConfig");
@@ -29409,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.7"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("decorators", metadata.decorators);
@@ -29428,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.7"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", metadata.type);
   definitionMap.set("resolveDeferredDeps", compileComponentMetadataAsyncResolver(dependencies));
@@ -29497,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.7"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone !== void 0) {
     definitionMap.set("isStandalone", literal(meta.isStandalone));
@@ -29825,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.7"));
+  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));
@@ -29848,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.7"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.providedIn !== void 0) {
@@ -29886,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.7"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   definitionMap.set("providers", meta.providers);
@@ -29910,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.7"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.bootstrap.length > 0) {
@@ -29945,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.7"));
+  definitionMap.set("version", literal("19.2.0"));
   definitionMap.set("ngImport", importExpr(Identifiers.core));
   definitionMap.set("type", meta.type.value);
   if (meta.isStandalone !== void 0) {
@@ -30081,11 +30326,15 @@ publishFacade(_global);
   SplitInterpolation,
   Statement,
   StmtModifier,
+  StringToken,
+  StringTokenKind,
   TagContentType,
-  TaggedTemplateExpr,
+  TaggedTemplateLiteralExpr,
   TemplateBindingParseResult,
   TemplateLiteral,
   TemplateLiteralElement,
+  TemplateLiteralElementExpr,
+  TemplateLiteralExpr,
   Text,
   ThisReceiver,
   TmplAstBlockNode,
@@ -30207,7 +30456,7 @@ publishFacade(_global);
 
 @angular/compiler/fesm2022/compiler.mjs:
   (**
-   * @license Angular v19.1.7
+   * @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.1",
+  "version": "19.1.1-alpha.2",
   "description": "A CJS bundled version of @angular/compiler",
   "license": "MIT",
   "main": "dist/index.js",