@angular-eslint/bundled-angular-compiler 18.0.2-alpha.0 → 18.0.2-alpha.10

package/dist/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * @license Angular v18.0.0
+ * @license Angular v18.0.5
  * (c) 2010-2024 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2886,6 +2886,9 @@ class Identifiers {
     static { this.twoWayProperty = { name: 'ɵɵtwoWayProperty', moduleName: CORE }; }
     static { this.twoWayBindingSet = { name: 'ɵɵtwoWayBindingSet', moduleName: CORE }; }
     static { this.twoWayListener = { name: 'ɵɵtwoWayListener', moduleName: CORE }; }
+    static { this.declareLet = { name: 'ɵɵdeclareLet', moduleName: CORE }; }
+    static { this.storeLet = { name: 'ɵɵstoreLet', moduleName: CORE }; }
+    static { this.readContextLet = { name: 'ɵɵreadContextLet', moduleName: CORE }; }
     static { this.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE }; }
     static { this.InheritDefinitionFeature = {
         name: 'ɵɵInheritDefinitionFeature',
@@ -5053,6 +5056,18 @@ class UnknownBlock {
         return visitor.visitUnknownBlock(this);
     }
 }
+class LetDeclaration$1 {
+    constructor(name, value, sourceSpan, nameSpan, valueSpan) {
+        this.name = name;
+        this.value = value;
+        this.sourceSpan = sourceSpan;
+        this.nameSpan = nameSpan;
+        this.valueSpan = valueSpan;
+    }
+    visit(visitor) {
+        return visitor.visitLetDeclaration(this);
+    }
+}
 class Template {
     constructor(
     // tagName is the name of the container element, if applicable.
@@ -5188,6 +5203,7 @@ class RecursiveVisitor$1 {
     visitIcu(icu) { }
     visitDeferredTrigger(trigger) { }
     visitUnknownBlock(block) { }
+    visitLetDeclaration(decl) { }
 }
 function visitAll$1(visitor, nodes) {
     const result = [];
@@ -8191,46 +8207,54 @@ var OpKind;
      * An operation declaring the event side of a two-way binding.
      */
     OpKind[OpKind["TwoWayListener"] = 37] = "TwoWayListener";
+    /**
+     * A creation-time operation that initializes the slot for a `@let` declaration.
+     */
+    OpKind[OpKind["DeclareLet"] = 38] = "DeclareLet";
+    /**
+     * An update-time operation that stores the current value of a `@let` declaration.
+     */
+    OpKind[OpKind["StoreLet"] = 39] = "StoreLet";
     /**
      * The start of an i18n block.
      */
-    OpKind[OpKind["I18nStart"] = 38] = "I18nStart";
+    OpKind[OpKind["I18nStart"] = 40] = "I18nStart";
     /**
      * A self-closing i18n on a single element.
      */
-    OpKind[OpKind["I18n"] = 39] = "I18n";
+    OpKind[OpKind["I18n"] = 41] = "I18n";
     /**
      * The end of an i18n block.
      */
-    OpKind[OpKind["I18nEnd"] = 40] = "I18nEnd";
+    OpKind[OpKind["I18nEnd"] = 42] = "I18nEnd";
     /**
      * An expression in an i18n message.
      */
-    OpKind[OpKind["I18nExpression"] = 41] = "I18nExpression";
+    OpKind[OpKind["I18nExpression"] = 43] = "I18nExpression";
     /**
      * An instruction that applies a set of i18n expressions.
      */
-    OpKind[OpKind["I18nApply"] = 42] = "I18nApply";
+    OpKind[OpKind["I18nApply"] = 44] = "I18nApply";
     /**
      * An instruction to create an ICU expression.
      */
-    OpKind[OpKind["IcuStart"] = 43] = "IcuStart";
+    OpKind[OpKind["IcuStart"] = 45] = "IcuStart";
     /**
      * An instruction to update an ICU expression.
      */
-    OpKind[OpKind["IcuEnd"] = 44] = "IcuEnd";
+    OpKind[OpKind["IcuEnd"] = 46] = "IcuEnd";
     /**
      * An instruction representing a placeholder in an ICU expression.
      */
-    OpKind[OpKind["IcuPlaceholder"] = 45] = "IcuPlaceholder";
+    OpKind[OpKind["IcuPlaceholder"] = 47] = "IcuPlaceholder";
     /**
      * An i18n context containing information needed to generate an i18n message.
      */
-    OpKind[OpKind["I18nContext"] = 46] = "I18nContext";
+    OpKind[OpKind["I18nContext"] = 48] = "I18nContext";
     /**
      * A creation op that corresponds to i18n attributes on an element.
      */
-    OpKind[OpKind["I18nAttributes"] = 47] = "I18nAttributes";
+    OpKind[OpKind["I18nAttributes"] = 49] = "I18nAttributes";
 })(OpKind || (OpKind = {}));
 /**
  * Distinguishes different kinds of IR expressions.
@@ -8261,78 +8285,86 @@ var ExpressionKind;
      * Runtime operation to retrieve the value of a local reference.
      */
     ExpressionKind[ExpressionKind["Reference"] = 5] = "Reference";
+    /**
+     * A call storing the value of a `@let` declaration.
+     */
+    ExpressionKind[ExpressionKind["StoreLet"] = 6] = "StoreLet";
+    /**
+     * A reference to a `@let` declaration read from the context view.
+     */
+    ExpressionKind[ExpressionKind["ContextLetReference"] = 7] = "ContextLetReference";
     /**
      * Runtime operation to snapshot the current view context.
      */
-    ExpressionKind[ExpressionKind["GetCurrentView"] = 6] = "GetCurrentView";
+    ExpressionKind[ExpressionKind["GetCurrentView"] = 8] = "GetCurrentView";
     /**
      * Runtime operation to restore a snapshotted view.
      */
-    ExpressionKind[ExpressionKind["RestoreView"] = 7] = "RestoreView";
+    ExpressionKind[ExpressionKind["RestoreView"] = 9] = "RestoreView";
     /**
      * Runtime operation to reset the current view context after `RestoreView`.
      */
-    ExpressionKind[ExpressionKind["ResetView"] = 8] = "ResetView";
+    ExpressionKind[ExpressionKind["ResetView"] = 10] = "ResetView";
     /**
      * Defines and calls a function with change-detected arguments.
      */
-    ExpressionKind[ExpressionKind["PureFunctionExpr"] = 9] = "PureFunctionExpr";
+    ExpressionKind[ExpressionKind["PureFunctionExpr"] = 11] = "PureFunctionExpr";
     /**
      * Indicates a positional parameter to a pure function definition.
      */
-    ExpressionKind[ExpressionKind["PureFunctionParameterExpr"] = 10] = "PureFunctionParameterExpr";
+    ExpressionKind[ExpressionKind["PureFunctionParameterExpr"] = 12] = "PureFunctionParameterExpr";
     /**
      * Binding to a pipe transformation.
      */
-    ExpressionKind[ExpressionKind["PipeBinding"] = 11] = "PipeBinding";
+    ExpressionKind[ExpressionKind["PipeBinding"] = 13] = "PipeBinding";
     /**
      * Binding to a pipe transformation with a variable number of arguments.
      */
-    ExpressionKind[ExpressionKind["PipeBindingVariadic"] = 12] = "PipeBindingVariadic";
+    ExpressionKind[ExpressionKind["PipeBindingVariadic"] = 14] = "PipeBindingVariadic";
     /*
      * A safe property read requiring expansion into a null check.
      */
-    ExpressionKind[ExpressionKind["SafePropertyRead"] = 13] = "SafePropertyRead";
+    ExpressionKind[ExpressionKind["SafePropertyRead"] = 15] = "SafePropertyRead";
     /**
      * A safe keyed read requiring expansion into a null check.
      */
-    ExpressionKind[ExpressionKind["SafeKeyedRead"] = 14] = "SafeKeyedRead";
+    ExpressionKind[ExpressionKind["SafeKeyedRead"] = 16] = "SafeKeyedRead";
     /**
      * A safe function call requiring expansion into a null check.
      */
-    ExpressionKind[ExpressionKind["SafeInvokeFunction"] = 15] = "SafeInvokeFunction";
+    ExpressionKind[ExpressionKind["SafeInvokeFunction"] = 17] = "SafeInvokeFunction";
     /**
      * An intermediate expression that will be expanded from a safe read into an explicit ternary.
      */
-    ExpressionKind[ExpressionKind["SafeTernaryExpr"] = 16] = "SafeTernaryExpr";
+    ExpressionKind[ExpressionKind["SafeTernaryExpr"] = 18] = "SafeTernaryExpr";
     /**
      * An empty expression that will be stipped before generating the final output.
      */
-    ExpressionKind[ExpressionKind["EmptyExpr"] = 17] = "EmptyExpr";
+    ExpressionKind[ExpressionKind["EmptyExpr"] = 19] = "EmptyExpr";
     /*
      * An assignment to a temporary variable.
      */
-    ExpressionKind[ExpressionKind["AssignTemporaryExpr"] = 18] = "AssignTemporaryExpr";
+    ExpressionKind[ExpressionKind["AssignTemporaryExpr"] = 20] = "AssignTemporaryExpr";
     /**
      * A reference to a temporary variable.
      */
-    ExpressionKind[ExpressionKind["ReadTemporaryExpr"] = 19] = "ReadTemporaryExpr";
+    ExpressionKind[ExpressionKind["ReadTemporaryExpr"] = 21] = "ReadTemporaryExpr";
     /**
      * An expression that will cause a literal slot index to be emitted.
      */
-    ExpressionKind[ExpressionKind["SlotLiteralExpr"] = 20] = "SlotLiteralExpr";
+    ExpressionKind[ExpressionKind["SlotLiteralExpr"] = 22] = "SlotLiteralExpr";
     /**
      * A test expression for a conditional op.
      */
-    ExpressionKind[ExpressionKind["ConditionalCase"] = 21] = "ConditionalCase";
+    ExpressionKind[ExpressionKind["ConditionalCase"] = 23] = "ConditionalCase";
     /**
      * An expression that will be automatically extracted to the component const array.
      */
-    ExpressionKind[ExpressionKind["ConstCollected"] = 22] = "ConstCollected";
+    ExpressionKind[ExpressionKind["ConstCollected"] = 24] = "ConstCollected";
     /**
      * Operation that sets the value of a two-way binding.
      */
-    ExpressionKind[ExpressionKind["TwoWayBindingSet"] = 23] = "TwoWayBindingSet";
+    ExpressionKind[ExpressionKind["TwoWayBindingSet"] = 25] = "TwoWayBindingSet";
 })(ExpressionKind || (ExpressionKind = {}));
 var VariableFlags;
 (function (VariableFlags) {
@@ -8553,11 +8585,8 @@ const TRAIT_CONSUMES_VARS = {
 function hasConsumesSlotTrait(op) {
     return op[ConsumesSlot] === true;
 }
-/**
- * Test whether an operation implements `DependsOnSlotContextOpTrait`.
- */
-function hasDependsOnSlotContextTrait(op) {
-    return op[DependsOnSlotContext] === true;
+function hasDependsOnSlotContextTrait(value) {
+    return value[DependsOnSlotContext] === true;
 }
 function hasConsumesVarsTrait(value) {
     return value[ConsumesVarsTrait] === true;
@@ -8855,8 +8884,23 @@ function createI18nApplyOp(owner, handle, sourceSpan) {
         ...NEW_OP,
     };
 }
+/**
+ * Creates a `StoreLetOp`.
+ */
+function createStoreLetOp(target, declaredName, value, sourceSpan) {
+    return {
+        kind: OpKind.StoreLet,
+        target,
+        declaredName,
+        value,
+        sourceSpan,
+        ...TRAIT_DEPENDS_ON_SLOT_CONTEXT,
+        ...TRAIT_CONSUMES_VARS,
+        ...NEW_OP,
+    };
+}
 
-var _a, _b, _c, _d, _e, _f;
+var _a, _b, _c, _d, _e, _f, _g, _h;
 /**
  * Check whether a given `o.Expression` is a logical IR expression type.
  */
@@ -8918,6 +8962,50 @@ class ReferenceExpr extends ExpressionBase {
         return new ReferenceExpr(this.target, this.targetSlot, this.offset);
     }
 }
+class StoreLetExpr extends ExpressionBase {
+    static { _a = ConsumesVarsTrait, _b = DependsOnSlotContext; }
+    constructor(target, value, sourceSpan) {
+        super();
+        this.target = target;
+        this.value = value;
+        this.sourceSpan = sourceSpan;
+        this.kind = ExpressionKind.StoreLet;
+        this[_a] = true;
+        this[_b] = true;
+    }
+    visitExpression() { }
+    isEquivalent(e) {
+        return (e instanceof StoreLetExpr && e.target === this.target && e.value.isEquivalent(this.value));
+    }
+    isConstant() {
+        return false;
+    }
+    transformInternalExpressions(transform, flags) {
+        this.value = transformExpressionsInExpression(this.value, transform, flags);
+    }
+    clone() {
+        return new StoreLetExpr(this.target, this.value, this.sourceSpan);
+    }
+}
+class ContextLetReferenceExpr extends ExpressionBase {
+    constructor(target, targetSlot) {
+        super();
+        this.target = target;
+        this.targetSlot = targetSlot;
+        this.kind = ExpressionKind.ContextLetReference;
+    }
+    visitExpression() { }
+    isEquivalent(e) {
+        return e instanceof ContextLetReferenceExpr && e.target === this.target;
+    }
+    isConstant() {
+        return false;
+    }
+    transformInternalExpressions() { }
+    clone() {
+        return new ContextLetReferenceExpr(this.target, this.targetSlot);
+    }
+}
 /**
  * A reference to the current view context (usually the `ctx` variable in a template function).
  */
@@ -9118,12 +9206,12 @@ class ReadVariableExpr extends ExpressionBase {
     }
 }
 class PureFunctionExpr extends ExpressionBase {
-    static { _a = ConsumesVarsTrait, _b = UsesVarOffset; }
+    static { _c = ConsumesVarsTrait, _d = UsesVarOffset; }
     constructor(expression, args) {
         super();
         this.kind = ExpressionKind.PureFunctionExpr;
-        this[_a] = true;
-        this[_b] = true;
+        this[_c] = true;
+        this[_d] = true;
         this.varOffset = null;
         /**
          * Once extracted to the `ConstantPool`, a reference to the function which defines the computation
@@ -9189,7 +9277,7 @@ class PureFunctionParameterExpr extends ExpressionBase {
     }
 }
 class PipeBindingExpr extends ExpressionBase {
-    static { _c = ConsumesVarsTrait, _d = UsesVarOffset; }
+    static { _e = ConsumesVarsTrait, _f = UsesVarOffset; }
     constructor(target, targetSlot, name, args) {
         super();
         this.target = target;
@@ -9197,8 +9285,8 @@ class PipeBindingExpr extends ExpressionBase {
         this.name = name;
         this.args = args;
         this.kind = ExpressionKind.PipeBinding;
-        this[_c] = true;
-        this[_d] = true;
+        this[_e] = true;
+        this[_f] = true;
         this.varOffset = null;
     }
     visitExpression(visitor, context) {
@@ -9224,7 +9312,7 @@ class PipeBindingExpr extends ExpressionBase {
     }
 }
 class PipeBindingVariadicExpr extends ExpressionBase {
-    static { _e = ConsumesVarsTrait, _f = UsesVarOffset; }
+    static { _g = ConsumesVarsTrait, _h = UsesVarOffset; }
     constructor(target, targetSlot, name, args, numArgs) {
         super();
         this.target = target;
@@ -9233,8 +9321,8 @@ class PipeBindingVariadicExpr extends ExpressionBase {
         this.args = args;
         this.numArgs = numArgs;
         this.kind = ExpressionKind.PipeBindingVariadic;
-        this[_e] = true;
-        this[_f] = true;
+        this[_g] = true;
+        this[_h] = true;
         this.varOffset = null;
     }
     visitExpression(visitor, context) {
@@ -9628,6 +9716,9 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.DeferWhen:
             op.expr = transformExpressionsInExpression(op.expr, transform, flags);
             break;
+        case OpKind.StoreLet:
+            op.value = transformExpressionsInExpression(op.value, transform, flags);
+            break;
         case OpKind.Advance:
         case OpKind.Container:
         case OpKind.ContainerEnd:
@@ -9653,6 +9744,7 @@ function transformExpressionsInOp(op, transform, flags) {
         case OpKind.Text:
         case OpKind.I18nAttributes:
         case OpKind.IcuPlaceholder:
+        case OpKind.DeclareLet:
             // These operations contain no expressions.
             break;
         default:
@@ -10316,6 +10408,20 @@ function createDeferOnOp(defer, trigger, prefetch, sourceSpan) {
         ...NEW_OP,
     };
 }
+/**
+ * Creates a `DeclareLetOp`.
+ */
+function createDeclareLetOp(xref, declaredName, sourceSpan) {
+    return {
+        kind: OpKind.DeclareLet,
+        xref,
+        declaredName,
+        sourceSpan,
+        handle: new SlotHandle(),
+        ...TRAIT_CONSUMES_SLOT,
+        ...NEW_OP,
+    };
+}
 /**
  * Create an `ExtractedMessageOp`.
  */
@@ -11009,6 +11115,7 @@ const CHAINABLE = new Set([
     Identifiers.templateCreate,
     Identifiers.twoWayProperty,
     Identifiers.twoWayListener,
+    Identifiers.declareLet,
 ]);
 /**
  * Post-process a reified view compilation and convert sequential calls to chainable instructions
@@ -12174,16 +12281,26 @@ function generateAdvance(job) {
         // To do that, we track what the runtime's slot counter will be through the update operations.
         let slotContext = 0;
         for (const op of unit.update) {
-            if (!hasDependsOnSlotContextTrait(op)) {
-                // `op` doesn't depend on the slot counter, so it can be skipped.
+            let consumer = null;
+            if (hasDependsOnSlotContextTrait(op)) {
+                consumer = op;
+            }
+            else {
+                visitExpressionsInOp(op, (expr) => {
+                    if (consumer === null && hasDependsOnSlotContextTrait(expr)) {
+                        consumer = expr;
+                    }
+                });
+            }
+            if (consumer === null) {
                 continue;
             }
-            else if (!slotMap.has(op.target)) {
+            if (!slotMap.has(consumer.target)) {
                 // We expect ops that _do_ depend on the slot counter to point at declarations that exist in
                 // the `slotMap`.
-                throw new Error(`AssertionError: reference to unknown slot for target ${op.target}`);
+                throw new Error(`AssertionError: reference to unknown slot for target ${consumer.target}`);
             }
-            const slot = slotMap.get(op.target);
+            const slot = slotMap.get(consumer.target);
             // Does the slot counter need to be adjusted?
             if (slotContext !== slot) {
                 // If so, generate an `ir.AdvanceOp` to advance the counter.
@@ -12191,7 +12308,7 @@ function generateAdvance(job) {
                 if (delta < 0) {
                     throw new Error(`AssertionError: slot counter should never need to move backwards`);
                 }
-                OpList.insertBefore(createAdvanceOp(delta, op.sourceSpan), op);
+                OpList.insertBefore(createAdvanceOp(delta, consumer.sourceSpan), op);
                 slotContext = slot;
             }
         }
@@ -12282,13 +12399,11 @@ function recursivelyProcessView(view, parentScope) {
             case OpKind.Listener:
             case OpKind.TwoWayListener:
                 // Prepend variables to listener handler functions.
-                op.handlerOps.prepend(generateVariablesInScopeForView(view, scope));
+                op.handlerOps.prepend(generateVariablesInScopeForView(view, scope, true));
                 break;
         }
     }
-    // Prepend the declarations for all available variables in scope to the `update` block.
-    const preambleOps = generateVariablesInScopeForView(view, scope);
-    view.update.prepend(preambleOps);
+    view.update.prepend(generateVariablesInScopeForView(view, scope, false));
 }
 /**
  * Process a view and generate a `Scope` representing the variables available for reference within
@@ -12305,6 +12420,7 @@ function getScopeForView(view, parent) {
         contextVariables: new Map(),
         aliases: view.aliases,
         references: [],
+        letDeclarations: [],
         parent,
     };
     for (const identifier of view.contextVariables.keys()) {
@@ -12336,6 +12452,17 @@ function getScopeForView(view, parent) {
                     });
                 }
                 break;
+            case OpKind.DeclareLet:
+                scope.letDeclarations.push({
+                    targetId: op.xref,
+                    targetSlot: op.handle,
+                    variable: {
+                        kind: SemanticVariableKind.Identifier,
+                        name: null,
+                        identifier: op.declaredName,
+                    },
+                });
+                break;
         }
     }
     return scope;
@@ -12346,7 +12473,7 @@ function getScopeForView(view, parent) {
  * This is a recursive process, as views inherit variables available from their parent view, which
  * itself may have inherited variables, etc.
  */
-function generateVariablesInScopeForView(view, scope) {
+function generateVariablesInScopeForView(view, scope, isListener) {
     const newOps = [];
     if (scope.view !== view.xref) {
         // Before generating variables for a parent view, we need to switch to the context of the parent
@@ -12370,9 +12497,14 @@ function generateVariablesInScopeForView(view, scope) {
     for (const ref of scope.references) {
         newOps.push(createVariableOp(view.job.allocateXrefId(), ref.variable, new ReferenceExpr(ref.targetId, ref.targetSlot, ref.offset), VariableFlags.None));
     }
+    if (scope.view !== view.xref || isListener) {
+        for (const decl of scope.letDeclarations) {
+            newOps.push(createVariableOp(view.job.allocateXrefId(), decl.variable, new ContextLetReferenceExpr(decl.targetId, decl.targetSlot), VariableFlags.None));
+        }
+    }
     if (scope.parent !== null) {
         // Recursively add variables from the parent scope.
-        newOps.push(...generateVariablesInScopeForView(view, scope.parent));
+        newOps.push(...generateVariablesInScopeForView(view, scope.parent, false));
     }
     return newOps;
 }
@@ -13730,7 +13862,8 @@ class _ParseAST {
                 const keyStart = this.inputIndex;
                 const quoted = this.next.isString();
                 const key = this.expectIdentifierOrKeywordOrString();
-                keys.push({ key, quoted });
+                const literalMapKey = { key, quoted };
+                keys.push(literalMapKey);
                 // Properties with quoted keys can't use the shorthand syntax.
                 if (quoted) {
                     this.expectCharacter($COLON);
@@ -13740,6 +13873,7 @@ class _ParseAST {
                     values.push(this.parsePipe());
                 }
                 else {
+                    literalMapKey.isShorthandInitialized = true;
                     const span = this.span(keyStart);
                     const sourceSpan = this.sourceSpan(keyStart);
                     values.push(new PropertyRead(span, sourceSpan, sourceSpan, new ImplicitReceiver(span, sourceSpan), key));
@@ -14229,6 +14363,18 @@ class BlockParameter {
         return visitor.visitBlockParameter(this, context);
     }
 }
+class LetDeclaration {
+    constructor(name, value, sourceSpan, nameSpan, valueSpan) {
+        this.name = name;
+        this.value = value;
+        this.sourceSpan = sourceSpan;
+        this.nameSpan = nameSpan;
+        this.valueSpan = valueSpan;
+    }
+    visit(visitor, context) {
+        return visitor.visitLetDeclaration(this, context);
+    }
+}
 function visitAll(visitor, nodes, context = null) {
     const result = [];
     const visit = visitor.visit
@@ -14266,6 +14412,7 @@ class RecursiveVisitor {
         });
     }
     visitBlockParameter(ast, context) { }
+    visitLetDeclaration(decl, context) { }
     visitChildren(context, cb) {
         let results = [];
         let t = this;
@@ -15229,6 +15376,9 @@ class _I18nVisitor {
     visitBlockParameter(_parameter, _context) {
         throw new Error('Unreachable code');
     }
+    visitLetDeclaration(decl, context) {
+        return null;
+    }
     /**
      * Convert, text and interpolated tokens up into text and placeholder pieces.
      *
@@ -17554,6 +17704,8 @@ class _Tokenizer {
         this._preserveLineEndings = options.preserveLineEndings || false;
         this._i18nNormalizeLineEndingsInICUs = options.i18nNormalizeLineEndingsInICUs || false;
         this._tokenizeBlocks = options.tokenizeBlocks ?? true;
+        // TODO(crisbeto): eventually set this to true.
+        this._tokenizeLet = options.tokenizeLet || false;
         try {
             this._cursor.init();
         }
@@ -17594,6 +17746,14 @@ class _Tokenizer {
                         this._consumeTagOpen(start);
                     }
                 }
+                else if (this._tokenizeLet &&
+                    // Use `peek` instead of `attempCharCode` since we
+                    // don't want to advance in case it's not `@let`.
+                    this._cursor.peek() === $AT &&
+                    !this._inInterpolation &&
+                    this._attemptStr('@let')) {
+                    this._consumeLetDeclaration(start);
+                }
                 else if (this._tokenizeBlocks && this._attemptCharCode($AT)) {
                     this._consumeBlockStart(start);
                 }
@@ -17614,7 +17774,7 @@ class _Tokenizer {
                 this.handleError(e);
             }
         }
-        this._beginToken(29 /* TokenType.EOF */);
+        this._beginToken(33 /* TokenType.EOF */);
         this._endToken([]);
     }
     _getBlockName() {
@@ -17705,6 +17865,77 @@ class _Tokenizer {
             this._attemptCharCodeUntilFn(isBlockParameterChar);
         }
     }
+    _consumeLetDeclaration(start) {
+        this._beginToken(29 /* TokenType.LET_START */, start);
+        // Require at least one white space after the `@let`.
+        if (isWhitespace(this._cursor.peek())) {
+            this._attemptCharCodeUntilFn(isNotWhitespace);
+        }
+        else {
+            const token = this._endToken([this._cursor.getChars(start)]);
+            token.type = 32 /* TokenType.INCOMPLETE_LET */;
+            return;
+        }
+        const startToken = this._endToken([this._getLetDeclarationName()]);
+        // Skip over white space before the equals character.
+        this._attemptCharCodeUntilFn(isNotWhitespace);
+        // Expect an equals sign.
+        if (!this._attemptCharCode($EQ)) {
+            startToken.type = 32 /* TokenType.INCOMPLETE_LET */;
+            return;
+        }
+        // Skip spaces after the equals.
+        this._attemptCharCodeUntilFn((code) => isNotWhitespace(code) && !isNewLine(code));
+        this._consumeLetDeclarationValue();
+        // Terminate the `@let` with a semicolon.
+        const endChar = this._cursor.peek();
+        if (endChar === $SEMICOLON) {
+            this._beginToken(31 /* TokenType.LET_END */);
+            this._endToken([]);
+            this._cursor.advance();
+        }
+        else {
+            startToken.type = 32 /* TokenType.INCOMPLETE_LET */;
+            startToken.sourceSpan = this._cursor.getSpan(start);
+        }
+    }
+    _getLetDeclarationName() {
+        const nameCursor = this._cursor.clone();
+        let allowDigit = false;
+        this._attemptCharCodeUntilFn((code) => {
+            // `@let` names can't start with a digit, but digits are valid anywhere else in the name.
+            if (isAsciiLetter(code) || code === $_ || (allowDigit && isDigit(code))) {
+                allowDigit = true;
+                return false;
+            }
+            return true;
+        });
+        return this._cursor.getChars(nameCursor).trim();
+    }
+    _consumeLetDeclarationValue() {
+        const start = this._cursor.clone();
+        this._beginToken(30 /* TokenType.LET_VALUE */, start);
+        while (this._cursor.peek() !== $EOF) {
+            const char = this._cursor.peek();
+            // `@let` declarations terminate with a semicolon.
+            if (char === $SEMICOLON) {
+                break;
+            }
+            // If we hit a quote, skip over its content since we don't care what's inside.
+            if (isQuote(char)) {
+                this._cursor.advance();
+                this._attemptCharCodeUntilFn((inner) => {
+                    if (inner === $BACKSLASH) {
+                        this._cursor.advance();
+                        return false;
+                    }
+                    return inner === char;
+                });
+            }
+            this._cursor.advance();
+        }
+        this._endToken([this._cursor.getChars(start)]);
+    }
     /**
      * @returns whether an ICU token has been created
      * @internal
@@ -18635,7 +18866,7 @@ class _TreeBuilder {
         this._advance();
     }
     build() {
-        while (this._peek.type !== 29 /* TokenType.EOF */) {
+        while (this._peek.type !== 33 /* TokenType.EOF */) {
             if (this._peek.type === 0 /* TokenType.TAG_OPEN_START */ ||
                 this._peek.type === 4 /* TokenType.INCOMPLETE_TAG_OPEN */) {
                 this._consumeStartTag(this._advance());
@@ -18672,6 +18903,14 @@ class _TreeBuilder {
                 this._closeVoidElement();
                 this._consumeIncompleteBlock(this._advance());
             }
+            else if (this._peek.type === 29 /* TokenType.LET_START */) {
+                this._closeVoidElement();
+                this._consumeLet(this._advance());
+            }
+            else if (this._peek.type === 32 /* TokenType.INCOMPLETE_LET */) {
+                this._closeVoidElement();
+                this._consumeIncompleteLet(this._advance());
+            }
             else {
                 // Skip all other tokens...
                 this._advance();
@@ -18745,7 +18984,7 @@ class _TreeBuilder {
         if (!exp)
             return null;
         const end = this._advance();
-        exp.push({ type: 29 /* TokenType.EOF */, parts: [], sourceSpan: end.sourceSpan });
+        exp.push({ type: 33 /* TokenType.EOF */, parts: [], sourceSpan: end.sourceSpan });
         // parse everything in between { and }
         const expansionCaseParser = new _TreeBuilder(exp, this.getTagDefinition);
         expansionCaseParser.build();
@@ -18785,7 +19024,7 @@ class _TreeBuilder {
                     return null;
                 }
             }
-            if (this._peek.type === 29 /* TokenType.EOF */) {
+            if (this._peek.type === 33 /* TokenType.EOF */) {
                 this.errors.push(TreeError.create(null, start.sourceSpan, `Invalid ICU message. Missing '}'.`));
                 return null;
             }
@@ -19015,6 +19254,51 @@ class _TreeBuilder {
         this.errors.push(TreeError.create(token.parts[0], span, `Incomplete block "${token.parts[0]}". If you meant to write the @ character, ` +
             `you should use the "&#64;" HTML entity instead.`));
     }
+    _consumeLet(startToken) {
+        const name = startToken.parts[0];
+        let valueToken;
+        let endToken;
+        if (this._peek.type !== 30 /* TokenType.LET_VALUE */) {
+            this.errors.push(TreeError.create(startToken.parts[0], startToken.sourceSpan, `Invalid @let declaration "${name}". Declaration must have a value.`));
+            return;
+        }
+        else {
+            valueToken = this._advance();
+        }
+        // Type cast is necessary here since TS narrowed the type of `peek` above.
+        if (this._peek.type !== 31 /* TokenType.LET_END */) {
+            this.errors.push(TreeError.create(startToken.parts[0], startToken.sourceSpan, `Unterminated @let declaration "${name}". Declaration must be terminated with a semicolon.`));
+            return;
+        }
+        else {
+            endToken = this._advance();
+        }
+        const end = endToken.sourceSpan.fullStart;
+        const span = new ParseSourceSpan(startToken.sourceSpan.start, end, startToken.sourceSpan.fullStart);
+        // The start token usually captures the `@let`. Construct a name span by
+        // offsetting the start by the length of any text before the name.
+        const startOffset = startToken.sourceSpan.toString().lastIndexOf(name);
+        const nameStart = startToken.sourceSpan.start.moveBy(startOffset);
+        const nameSpan = new ParseSourceSpan(nameStart, startToken.sourceSpan.end);
+        const node = new LetDeclaration(name, valueToken.parts[0], span, nameSpan, valueToken.sourceSpan);
+        this._addToParent(node);
+    }
+    _consumeIncompleteLet(token) {
+        // Incomplete `@let` declaration may end up with an empty name.
+        const name = token.parts[0] ?? '';
+        const nameString = name ? ` "${name}"` : '';
+        // If there's at least a name, we can salvage an AST node that can be used for completions.
+        if (name.length > 0) {
+            const startOffset = token.sourceSpan.toString().lastIndexOf(name);
+            const nameStart = token.sourceSpan.start.moveBy(startOffset);
+            const nameSpan = new ParseSourceSpan(nameStart, token.sourceSpan.end);
+            const valueSpan = new ParseSourceSpan(token.sourceSpan.start, token.sourceSpan.start.moveBy(0));
+            const node = new LetDeclaration(name, '', token.sourceSpan, nameSpan, valueSpan);
+            this._addToParent(node);
+        }
+        this.errors.push(TreeError.create(token.parts[0], token.sourceSpan, `Incomplete @let declaration${nameString}. ` +
+            `@let declarations must be written as \`@let <name> = <value>;\``));
+    }
     _getContainer() {
         return this._containerStack.length > 0
             ? this._containerStack[this._containerStack.length - 1]
@@ -19243,6 +19527,9 @@ class I18nMetaVisitor {
     visitBlockParameter(parameter, context) {
         return parameter;
     }
+    visitLetDeclaration(decl, context) {
+        return decl;
+    }
     /**
      * Parse the general form `meta` passed into extract the explicit metadata needed to create a
      * `Message`.
@@ -20351,6 +20638,7 @@ function mergeNextContextsInOps(ops) {
                         break;
                     case ExpressionKind.GetCurrentView:
                     case ExpressionKind.Reference:
+                    case ExpressionKind.ContextLetReference:
                         // Can't merge past a dependency on the context.
                         tryToMerge = false;
                         break;
@@ -21076,6 +21364,15 @@ function repeater(collection, sourceSpan) {
 function deferWhen(prefetch, expr, sourceSpan) {
     return call(prefetch ? Identifiers.deferPrefetchWhen : Identifiers.deferWhen, [expr], sourceSpan);
 }
+function declareLet(slot, sourceSpan) {
+    return call(Identifiers.declareLet, [literal(slot)], sourceSpan);
+}
+function storeLet(value, sourceSpan) {
+    return importExpr(Identifiers.storeLet).callFn([value], sourceSpan);
+}
+function readContextLet(slot) {
+    return importExpr(Identifiers.readContextLet).callFn([literal(slot)]);
+}
 function i18n(slot, constIndex, subTemplateIndex, sourceSpan) {
     const args = [literal(slot), literal(constIndex)];
     if (subTemplateIndex) {
@@ -21487,6 +21784,9 @@ function reifyCreateOperations(unit, ops) {
             case OpKind.Pipe:
                 OpList.replace(op, pipe(op.handle.slot, op.name));
                 break;
+            case OpKind.DeclareLet:
+                OpList.replace(op, declareLet(op.handle.slot, op.sourceSpan));
+                break;
             case OpKind.Listener:
                 const listenerFn = reifyListenerHandler(unit, op.handlerFnName, op.handlerOps, op.consumesDollarEvent);
                 const eventTargetResolver = op.eventTarget
@@ -21706,6 +22006,8 @@ function reifyUpdateOperations(_unit, ops) {
             case OpKind.DeferWhen:
                 OpList.replace(op, deferWhen(op.prefetch, op.expr, op.sourceSpan));
                 break;
+            case OpKind.StoreLet:
+                throw new Error(`AssertionError: unexpected storeLet ${op.declaredName}`);
             case OpKind.Statement:
                 // Pass statement operations directly through.
                 break;
@@ -21764,6 +22066,10 @@ function reifyIrExpression(expr) {
             return pipeBindV(expr.targetSlot.slot, expr.varOffset, expr.args);
         case ExpressionKind.SlotLiteralExpr:
             return literal(expr.slot.slot);
+        case ExpressionKind.ContextLetReference:
+            return readContextLet(expr.targetSlot.slot);
+        case ExpressionKind.StoreLet:
+            return storeLet(expr.value, expr.sourceSpan);
         default:
             throw new Error(`AssertionError: Unsupported reification of ir.Expression kind: ${ExpressionKind[expr.kind]}`);
     }
@@ -22522,7 +22828,7 @@ function saveAndRestoreView(job) {
             if (!needsRestoreView) {
                 for (const handlerOp of op.handlerOps) {
                     visitExpressionsInOp(handlerOp, (expr) => {
-                        if (expr instanceof ReferenceExpr) {
+                        if (expr instanceof ReferenceExpr || expr instanceof ContextLetReferenceExpr) {
                             // Listeners that reference() a local ref need the save/restore view operation.
                             needsRestoreView = true;
                         }
@@ -22820,7 +23126,7 @@ function optimizeTrackFns(job) {
     }
 }
 function isTrackByFunctionCall(rootView, expr) {
-    if (!(expr instanceof InvokeFunctionExpr) || expr.args.length !== 2) {
+    if (!(expr instanceof InvokeFunctionExpr) || expr.args.length === 0 || expr.args.length > 2) {
         return false;
     }
     if (!(expr.receiver instanceof ReadPropExpr && expr.receiver.receiver instanceof ContextExpr) ||
@@ -22831,6 +23137,9 @@ function isTrackByFunctionCall(rootView, expr) {
     if (!(arg0 instanceof ReadVarExpr) || arg0.name !== '$index') {
         return false;
     }
+    else if (expr.args.length === 1) {
+        return true;
+    }
     if (!(arg1 instanceof ReadVarExpr) || arg1.name !== '$item') {
         return false;
     }
@@ -22974,6 +23283,7 @@ function varsUsedByOp(op) {
         case OpKind.I18nExpression:
         case OpKind.Conditional:
         case OpKind.DeferWhen:
+        case OpKind.StoreLet:
             return 1;
         case OpKind.RepeaterCreate:
             // Repeaters may require an extra variable binding slot, if they have an empty view, for the
@@ -22993,6 +23303,8 @@ function varsUsedByIrExpression(expr) {
             return 1 + expr.args.length;
         case ExpressionKind.PipeBindingVariadic:
             return 1 + expr.numArgs;
+        case ExpressionKind.StoreLet:
+            return 1;
         default:
             throw new Error(`AssertionError: unhandled ConsumesVarsTrait expression ${expr.constructor.name}`);
     }
@@ -23249,7 +23561,10 @@ function fencesForIrExpression(expr) {
             return Fence.ViewContextRead | Fence.ViewContextWrite;
         case ExpressionKind.RestoreView:
             return Fence.ViewContextRead | Fence.ViewContextWrite | Fence.SideEffectful;
+        case ExpressionKind.StoreLet:
+            return Fence.SideEffectful;
         case ExpressionKind.Reference:
+        case ExpressionKind.ContextLetReference:
             return Fence.ViewContextRead;
         default:
             return Fence.None;
@@ -23451,6 +23766,87 @@ function wrapI18nIcus(job) {
     }
 }
 
+/*!
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/**
+ * Removes any `storeLet` calls that aren't referenced outside of the current view.
+ */
+function optimizeStoreLet(job) {
+    const letUsedExternally = new Set();
+    // Since `@let` declarations can be referenced in child views, both in
+    // the creation block (via listeners) and in the update block, we have
+    // to look through all the ops to find the references.
+    for (const unit of job.units) {
+        for (const op of unit.ops()) {
+            visitExpressionsInOp(op, (expr) => {
+                if (expr instanceof ContextLetReferenceExpr) {
+                    letUsedExternally.add(expr.target);
+                }
+            });
+        }
+    }
+    // TODO(crisbeto): potentially remove the unused calls completely, pending discussion.
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            transformExpressionsInOp(op, (expression) => expression instanceof StoreLetExpr && !letUsedExternally.has(expression.target)
+                ? expression.value
+                : expression, VisitorContextFlag.None);
+        }
+    }
+}
+
+/**
+ * It's not allowed to access a `@let` declaration before it has been defined. This is enforced
+ * already via template type checking, however it can trip some of the assertions in the pipeline.
+ * E.g. the naming phase can fail because we resolved the variable here, but the variable doesn't
+ * exist anymore because the optimization phase removed it since it's invalid. To avoid surfacing
+ * confusing errors to users in the case where template type checking isn't running (e.g. in JIT
+ * mode) this phase detects illegal forward references and replaces them with `undefined`.
+ * Eventually users will see the proper error from the template type checker.
+ */
+function removeIllegalLetReferences(job) {
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            if (op.kind !== OpKind.Variable ||
+                op.variable.kind !== SemanticVariableKind.Identifier ||
+                !(op.initializer instanceof StoreLetExpr)) {
+                continue;
+            }
+            const name = op.variable.identifier;
+            let current = op;
+            while (current && current.kind !== OpKind.ListEnd) {
+                transformExpressionsInOp(current, (expr) => expr instanceof LexicalReadExpr && expr.name === name ? literal(undefined) : expr, VisitorContextFlag.None);
+                current = current.prev;
+            }
+        }
+    }
+}
+
+/**
+ * Replaces the `storeLet` ops with variables that can be
+ * used to reference the value within the same view.
+ */
+function generateLocalLetReferences(job) {
+    for (const unit of job.units) {
+        for (const op of unit.update) {
+            if (op.kind !== OpKind.StoreLet) {
+                continue;
+            }
+            const variable = {
+                kind: SemanticVariableKind.Identifier,
+                name: null,
+                identifier: op.declaredName,
+            };
+            OpList.replace(op, createVariableOp(job.allocateXrefId(), variable, new StoreLetExpr(op.target, op.value, op.sourceSpan), VariableFlags.None));
+        }
+    }
+}
+
 /**
  *
  * @license
@@ -23485,11 +23881,13 @@ const phases = [
     { kind: CompilationJobKind.Tmpl, fn: createVariadicPipes },
     { kind: CompilationJobKind.Both, fn: generatePureLiteralStructures },
     { kind: CompilationJobKind.Tmpl, fn: generateProjectionDefs },
+    { kind: CompilationJobKind.Tmpl, fn: generateLocalLetReferences },
     { kind: CompilationJobKind.Tmpl, fn: generateVariables },
     { kind: CompilationJobKind.Tmpl, fn: saveAndRestoreView },
     { kind: CompilationJobKind.Both, fn: deleteAnyCasts },
     { kind: CompilationJobKind.Both, fn: resolveDollarEvent },
     { kind: CompilationJobKind.Tmpl, fn: generateTrackVariables },
+    { kind: CompilationJobKind.Tmpl, fn: removeIllegalLetReferences },
     { kind: CompilationJobKind.Both, fn: resolveNames },
     { kind: CompilationJobKind.Tmpl, fn: resolveDeferTargetNames },
     { kind: CompilationJobKind.Tmpl, fn: transformTwoWayBindingSet },
@@ -23501,6 +23899,7 @@ const phases = [
     { kind: CompilationJobKind.Both, fn: expandSafeReads },
     { kind: CompilationJobKind.Both, fn: generateTemporaryVariables },
     { kind: CompilationJobKind.Both, fn: optimizeVariables },
+    { kind: CompilationJobKind.Both, fn: optimizeStoreLet },
     { kind: CompilationJobKind.Tmpl, fn: allocateSlots },
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nElementPlaceholders },
     { kind: CompilationJobKind.Tmpl, fn: resolveI18nExpressionPlaceholders },
@@ -23737,6 +24136,9 @@ function ingestNodes(unit, template) {
         else if (node instanceof ForLoopBlock) {
             ingestForBlock(unit, node);
         }
+        else if (node instanceof LetDeclaration$1) {
+            ingestLetDeclaration(unit, node);
+        }
         else {
             throw new Error(`Unsupported template node: ${node.constructor.name}`);
         }
@@ -24151,6 +24553,11 @@ function getComputedForLoopVariableExpression(variable, indexName, countName) {
             throw new Error(`AssertionError: unknown @for loop variable ${variable.value}`);
     }
 }
+function ingestLetDeclaration(unit, node) {
+    const target = unit.job.allocateXrefId();
+    unit.create.push(createDeclareLetOp(target, node.name, node.sourceSpan));
+    unit.update.push(createStoreLetOp(target, node.name, convertAst(node.value, unit.job, node.valueSpan), node.sourceSpan));
+}
 /**
  * Convert a template AST expression into an output AST expression.
  */
@@ -24176,7 +24583,7 @@ function convertAst(ast, job, baseSourceSpan) {
         // The whole point of the explicit `this` was to access the class property, but TDB and the
         // current TCB treat the read as implicit, and give you the context property instead!
         //
-        // For now, we emulate this old behvaior by aggressively converting explicit reads to to
+        // For now, we emulate this old behavior by aggressively converting explicit reads to to
         // implicit reads, except for the special cases that TDB and the current TCB protect. However,
         // it would be an improvement to fix this.
         //
@@ -24900,6 +25307,9 @@ class WhitespaceVisitor {
     visitBlockParameter(parameter, context) {
         return parameter;
     }
+    visitLetDeclaration(decl, context) {
+        return decl;
+    }
 }
 function createWhitespaceProcessedTextToken({ type, parts, sourceSpan }) {
     return { type, parts: [processWhitespace(parts[0])], sourceSpan };
@@ -26555,6 +26965,13 @@ class HtmlAstToIvyAst {
         }
         return null;
     }
+    visitLetDeclaration(decl, context) {
+        const value = this.bindingParser.parseBinding(decl.value, false, decl.valueSpan, decl.valueSpan.start.offset);
+        if (value.errors.length === 0 && value.ast instanceof EmptyExpr$1) {
+            this.reportError('@let declaration value cannot be empty', decl.valueSpan);
+        }
+        return new LetDeclaration$1(decl.name, value, decl.sourceSpan, decl.nameSpan, decl.valueSpan);
+    }
     visitBlockParameter() {
         return null;
     }
@@ -26833,6 +27250,9 @@ class NonBindableVisitor {
     visitBlockParameter(parameter, context) {
         return null;
     }
+    visitLetDeclaration(decl, context) {
+        return new Text$3(`@let ${decl.name} = ${decl.value};`, decl.sourceSpan);
+    }
 }
 const NON_BINDABLE_VISITOR = new NonBindableVisitor();
 function normalizeAttributeName(attrName) {
@@ -26867,6 +27287,7 @@ function parseTemplate(template, templateUrl, options = {}) {
         ...options,
         tokenizeExpansionForms: true,
         tokenizeBlocks: options.enableBlockSyntax ?? true,
+        tokenizeLet: options.enableLetSyntax ?? false,
     });
     if (!options.alwaysAttemptHtmlToR3AstConversion &&
         parseResult.errors &&
@@ -27636,6 +28057,9 @@ class Scope {
     visitContent(content) {
         this.ingestScopedNode(content);
     }
+    visitLetDeclaration(decl) {
+        this.maybeDeclare(decl);
+    }
     // Unused visitors.
     visitBoundAttribute(attr) { }
     visitBoundEvent(event) { }
@@ -27848,6 +28272,7 @@ class DirectiveBinder {
     visitIcu(icu) { }
     visitDeferredTrigger(trigger) { }
     visitUnknownBlock(block) { }
+    visitLetDeclaration(decl) { }
 }
 /**
  * Processes a template and extract metadata about expressions and symbols within.
@@ -28044,6 +28469,12 @@ class TemplateBinder extends RecursiveAstVisitor {
     visitBoundText(text) {
         text.value.visit(this);
     }
+    visitLetDeclaration(decl) {
+        decl.value.visit(this);
+        if (this.rootNode !== null) {
+            this.symbols.set(decl, this.rootNode);
+        }
+    }
     visitPipe(ast, context) {
         this.usedPipes.add(ast.name);
         if (!this.scope.isDeferred) {
@@ -28078,7 +28509,13 @@ class TemplateBinder extends RecursiveAstVisitor {
         }
         // Check whether the name exists in the current scope. If so, map it. Otherwise, the name is
         // probably a property on the top-level component context.
-        let target = this.scope.lookup(name);
+        const target = this.scope.lookup(name);
+        // It's not allowed to read template entities via `this`, however it previously worked by
+        // accident (see #55115). Since `@let` declarations are new, we can fix it from the beginning,
+        // whereas pre-existing template entities will be fixed in #55115.
+        if (target instanceof LetDeclaration$1 && ast.receiver instanceof ThisReceiver) {
+            return;
+        }
         if (target !== null) {
             this.bindings.set(ast, target);
         }
@@ -28276,6 +28713,7 @@ function extractScopedNodeEntities(rootScope) {
 class ResourceLoader {
 }
 
+let enableLetSyntax = false;
 class CompilerFacadeImpl {
     constructor(jitEvaluator = new JitEvaluator()) {
         this.jitEvaluator = jitEvaluator;
@@ -28684,7 +29122,11 @@ function parseJitTemplate(template, typeName, sourceMapUrl, preserveWhitespaces,
         ? InterpolationConfig.fromArray(interpolation)
         : DEFAULT_INTERPOLATION_CONFIG;
     // Parse the template and check for errors.
-    const parsed = parseTemplate(template, sourceMapUrl, { preserveWhitespaces, interpolationConfig });
+    const parsed = parseTemplate(template, sourceMapUrl, {
+        preserveWhitespaces,
+        interpolationConfig,
+        enableLetSyntax,
+    });
     if (parsed.errors !== null) {
         const errors = parsed.errors.map((err) => err.toString()).join(', ');
         throw new Error(`Errors during JIT compilation of template for ${typeName}: ${errors}`);
@@ -28913,7 +29355,7 @@ function publishFacade(global) {
  * @description
  * Entry point for all public APIs of the compiler package.
  */
-const VERSION = new Version('18.0.0');
+const VERSION = new Version('18.0.5');
 
 class CompilerConfig {
     constructor({ defaultEncapsulation = exports.ViewEncapsulation.Emulated, preserveWhitespaces, strictInjectionParameters, } = {}) {
@@ -29138,6 +29580,7 @@ class _Visitor {
         visitAll(this, block.children, context);
     }
     visitBlockParameter(parameter, context) { }
+    visitLetDeclaration(decl, context) { }
     _init(mode, interpolationConfig) {
         this._mode = mode;
         this._inI18nBlock = false;
@@ -29350,8 +29793,8 @@ class XmlParser extends Parser {
         super(getXmlTagDefinition);
     }
     parse(source, url, options = {}) {
-        // Blocks aren't supported in an XML context.
-        return super.parse(source, url, { ...options, tokenizeBlocks: false });
+        // Blocks and let declarations aren't supported in an XML context.
+        return super.parse(source, url, { ...options, tokenizeBlocks: false, tokenizeLet: false });
     }
 }
 
@@ -29572,6 +30015,7 @@ class XliffParser {
     visitExpansionCase(expansionCase, context) { }
     visitBlock(block, context) { }
     visitBlockParameter(parameter, context) { }
+    visitLetDeclaration(decl, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -29624,6 +30068,7 @@ class XmlToI18n$2 {
     visitAttribute(attribute, context) { }
     visitBlock(block, context) { }
     visitBlockParameter(parameter, context) { }
+    visitLetDeclaration(decl, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -29883,6 +30328,7 @@ class Xliff2Parser {
     visitExpansionCase(expansionCase, context) { }
     visitBlock(block, context) { }
     visitBlockParameter(parameter, context) { }
+    visitLetDeclaration(decl, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -29952,6 +30398,7 @@ class XmlToI18n$1 {
     visitAttribute(attribute, context) { }
     visitBlock(block, context) { }
     visitBlockParameter(parameter, context) { }
+    visitLetDeclaration(decl, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -30088,6 +30535,7 @@ class XtbParser {
     visitExpansionCase(expansionCase, context) { }
     visitBlock(block, context) { }
     visitBlockParameter(block, context) { }
+    visitLetDeclaration(decl, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -30138,6 +30586,7 @@ class XmlToI18n {
     visitAttribute(attribute, context) { }
     visitBlock(block, context) { }
     visitBlockParameter(block, context) { }
+    visitLetDeclaration(decl, context) { }
     _addError(node, message) {
         this._errors.push(new I18nError(node.sourceSpan, message));
     }
@@ -30544,7 +30993,7 @@ const 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('18.0.0'));
+    definitionMap.set('version', literal('18.0.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('decorators', metadata.decorators);
@@ -30562,7 +31011,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('18.0.0'));
+    definitionMap.set('version', literal('18.0.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', metadata.type);
     definitionMap.set('resolveDeferredDeps', compileComponentMetadataAsyncResolver(dependencies));
@@ -30657,7 +31106,7 @@ function createDirectiveDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     const minVersion = getMinimumVersionForPartialOutput(meta);
     definitionMap.set('minVersion', literal(minVersion));
-    definitionMap.set('version', literal('18.0.0'));
+    definitionMap.set('version', literal('18.0.5'));
     // e.g. `type: MyDirective`
     definitionMap.set('type', meta.type.value);
     if (meta.isStandalone) {
@@ -31076,7 +31525,7 @@ const 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('18.0.0'));
+    definitionMap.set('version', literal('18.0.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('deps', compileDependencies(meta.deps));
@@ -31111,7 +31560,7 @@ function compileDeclareInjectableFromMetadata(meta) {
 function createInjectableDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$3));
-    definitionMap.set('version', literal('18.0.0'));
+    definitionMap.set('version', literal('18.0.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // Only generate providedIn property if it has a non-null value
@@ -31162,7 +31611,7 @@ function compileDeclareInjectorFromMetadata(meta) {
 function createInjectorDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION$2));
-    definitionMap.set('version', literal('18.0.0'));
+    definitionMap.set('version', literal('18.0.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     definitionMap.set('providers', meta.providers);
@@ -31195,7 +31644,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('18.0.0'));
+    definitionMap.set('version', literal('18.0.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     definitionMap.set('type', meta.type.value);
     // We only generate the keys in the metadata if the arrays contain values.
@@ -31246,7 +31695,7 @@ function compileDeclarePipeFromMetadata(meta) {
 function createPipeDefinitionMap(meta) {
     const definitionMap = new DefinitionMap();
     definitionMap.set('minVersion', literal(MINIMUM_PARTIAL_LINKER_VERSION));
-    definitionMap.set('version', literal('18.0.0'));
+    definitionMap.set('version', literal('18.0.5'));
     definitionMap.set('ngImport', importExpr(Identifiers.core));
     // e.g. `type: MyPipe`
     definitionMap.set('type', meta.type.value);
@@ -31328,6 +31777,7 @@ exports.JitEvaluator = JitEvaluator;
 exports.KeyedRead = KeyedRead;
 exports.KeyedWrite = KeyedWrite;
 exports.LeadingComment = LeadingComment;
+exports.LetDeclaration = LetDeclaration;
 exports.Lexer = Lexer;
 exports.LiteralArray = LiteralArray;
 exports.LiteralArrayExpr = LiteralArrayExpr;
@@ -31404,6 +31854,7 @@ exports.TmplAstIfBlock = IfBlock;
 exports.TmplAstIfBlockBranch = IfBlockBranch;
 exports.TmplAstImmediateDeferredTrigger = ImmediateDeferredTrigger;
 exports.TmplAstInteractionDeferredTrigger = InteractionDeferredTrigger;
+exports.TmplAstLetDeclaration = LetDeclaration$1;
 exports.TmplAstRecursiveVisitor = RecursiveVisitor$1;
 exports.TmplAstReference = Reference;
 exports.TmplAstSwitchBlock = SwitchBlock;

package/package.json

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