@angular-eslint/eslint-plugin-template 19.2.2-alpha.4 → 19.2.2-alpha.6

package/README.md

@@ -61,6 +61,7 @@ Please see https://github.com/angular-eslint/angular-eslint for full usage instr
 | [`no-interpolation-in-attributes`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-interpolation-in-attributes.md) | Ensures that property-binding is used instead of interpolation in attributes. |  |  |  |  |
 | [`no-negated-async`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-negated-async.md) | Ensures that async pipe results, as well as values used with the async pipe, are not negated | :white_check_mark: |  | :bulb: |  |
 | [`no-positive-tabindex`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/no-positive-tabindex.md) | Ensures that the `tabindex` attribute is not positive |  |  | :bulb: |  |
+| [`prefer-contextual-for-variables`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-contextual-for-variables.md) | Ensures that contextual variables are used in @for blocks where possible instead of aliasing them. |  | :wrench: |  |  |
 | [`prefer-control-flow`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-control-flow.md) | Ensures that the built-in control flow is used. |  |  |  |  |
 | [`prefer-ngsrc`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/prefer-ngsrc.md) | Ensures ngSrc is used instead of src for img elements |  |  |  |  |
 | [`role-has-required-aria`](https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/role-has-required-aria.md) | [Accessibility] Ensures elements with ARIA roles have all required properties for that role. |  |  | :bulb: | :accessibility: |

package/dist/configs/all.json

@@ -24,6 +24,7 @@
     "@angular-eslint/template/no-interpolation-in-attributes": "error",
     "@angular-eslint/template/no-negated-async": "error",
     "@angular-eslint/template/no-positive-tabindex": "error",
+    "@angular-eslint/template/prefer-contextual-for-variables": "error",
     "@angular-eslint/template/prefer-control-flow": "error",
     "@angular-eslint/template/prefer-ngsrc": "error",
     "@angular-eslint/template/prefer-self-closing-tags": "error",

package/dist/index.d.ts

@@ -26,6 +26,7 @@ declare const _default: {
                 "@angular-eslint/template/no-interpolation-in-attributes": string;
                 "@angular-eslint/template/no-negated-async": string;
                 "@angular-eslint/template/no-positive-tabindex": string;
+                "@angular-eslint/template/prefer-contextual-for-variables": string;
                 "@angular-eslint/template/prefer-control-flow": string;
                 "@angular-eslint/template/prefer-ngsrc": string;
                 "@angular-eslint/template/prefer-self-closing-tags": string;
@@ -105,6 +106,7 @@ declare const _default: {
         "no-interpolation-in-attributes": import("@typescript-eslint/utils/ts-eslint").RuleModule<"noInterpolationInAttributes", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-negated-async": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-negated-async").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "no-positive-tabindex": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-positive-tabindex").MessageIds, [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        "prefer-contextual-for-variables": import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/prefer-contextual-for-variables").MessageIds, import("./rules/prefer-contextual-for-variables").Options, import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-control-flow": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferControlFlow", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-self-closing-tags": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSelfClosingTags", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         "prefer-static-string-properties": import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferStaticStringProperties", [], import("./utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsFA,kBAwCE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyFA,kBAyCE"}

package/dist/index.js

@@ -53,6 +53,7 @@ const no_interpolation_in_attributes_1 = __importStar(require("./rules/no-interp
 const no_negated_async_1 = __importStar(require("./rules/no-negated-async"));
 const no_positive_tabindex_1 = __importStar(require("./rules/no-positive-tabindex"));
 const prefer_ngsrc_1 = __importStar(require("./rules/prefer-ngsrc"));
+const prefer_contextual_for_variables_1 = __importStar(require("./rules/prefer-contextual-for-variables"));
 const prefer_control_flow_1 = __importStar(require("./rules/prefer-control-flow"));
 const prefer_self_closing_tags_1 = __importStar(require("./rules/prefer-self-closing-tags"));
 const prefer_static_string_properties_1 = __importStar(require("./rules/prefer-static-string-properties"));
@@ -91,6 +92,7 @@ module.exports = {
         [no_interpolation_in_attributes_1.RULE_NAME]: no_interpolation_in_attributes_1.default,
         [no_negated_async_1.RULE_NAME]: no_negated_async_1.default,
         [no_positive_tabindex_1.RULE_NAME]: no_positive_tabindex_1.default,
+        [prefer_contextual_for_variables_1.RULE_NAME]: prefer_contextual_for_variables_1.default,
         [prefer_control_flow_1.RULE_NAME]: prefer_control_flow_1.default,
         [prefer_self_closing_tags_1.RULE_NAME]: prefer_self_closing_tags_1.default,
         [prefer_static_string_properties_1.RULE_NAME]: prefer_static_string_properties_1.default,

package/dist/rules/alt-text.js

@@ -21,7 +21,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     create(context) {
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         return {
-            'Element$1[name=/^(img|area|object|input)$/]'(node) {
+            'Element[name=/^(img|area|object|input)$/]'(node) {
                 const isValid = isValidNode(node);
                 if (!isValid) {
                     const loc = parserServices.convertElementSourceSpanToLoc(context, node);

package/dist/rules/attributes-order.js

@@ -67,7 +67,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             return adjustLocation(parserServices.convertNodeSourceSpanToLoc(attr.sourceSpan), 'location', attr);
         }
         return {
-            ['Element$1, Template'](node) {
+            ['Element, Template'](node) {
                 if (isImplicitTemplate(node)) {
                     return;
                 }

package/dist/rules/button-has-type.js

@@ -42,7 +42,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     create(context, [{ ignoreWithDirectives }]) {
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         return {
-            [`Element$1[name=button]`](element) {
+            [`Element[name=button]`](element) {
                 if (!isTypeAttributePresentInElement(element)) {
                     if (!isIgnored(ignoreWithDirectives, element)) {
                         context.report({

package/dist/rules/click-events-have-key-events.js

@@ -23,7 +23,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     defaultOptions: [],
     create(context) {
         return {
-            Element$1(node) {
+            Element(node) {
                 if (!(0, get_dom_elements_1.getDomElements)().has(node.name)) {
                     return;
                 }

package/dist/rules/conditional-complexity.js

@@ -53,7 +53,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                     data: { maxComplexity, totalComplexity },
                 });
             },
-            Interpolation$1({ expressions }) {
+            Interpolation({ expressions }) {
                 for (const expression of expressions) {
                     const totalComplexity = getTotalComplexity(expression);
                     if (totalComplexity <= maxComplexity) {

package/dist/rules/elements-content.js

@@ -44,7 +44,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     create(context, [{ allowList }]) {
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         return {
-            'Element$1[name=/^(a|button|h1|h2|h3|h4|h5|h6)$/][children.length=0]'(node) {
+            'Element[name=/^(a|button|h1|h2|h3|h4|h5|h6)$/][children.length=0]'(node) {
                 if ((0, is_hidden_from_screen_reader_1.isHiddenFromScreenReader)(node))
                     return;
                 const { attributes, inputs, name: element, sourceSpan } = node;

package/dist/rules/i18n.js

@@ -287,7 +287,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                 checkId ||
                 requireDescription ||
                 requireMeaning) && {
-                [`:matches(Element$1, Template[tagName="ng-template"])${allowMarkupInContent ? '[i18n]' : ''}`](node) {
+                [`:matches(Element, Template[tagName="ng-template"])${allowMarkupInContent ? '[i18n]' : ''}`](node) {
                     handleElementOrTemplate(node);
                 },
             }),
@@ -295,12 +295,12 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
                 checkId ||
                 requireDescription ||
                 requireMeaning) && {
-                [`Element$1 > TextAttribute[value=${PL_PATTERN}]`](node) {
+                [`Element > TextAttribute[value=${PL_PATTERN}]`](node) {
                     handleTextAttribute(node);
                 },
             }),
             ...(checkText && {
-                [`BoundText, Icu$1, Text$3[value=${PL_PATTERN}]`](node) {
+                [`BoundText, Icu, Text[value=${PL_PATTERN}]`](node) {
                     handleBoundTextOrIcuOrText(node);
                 },
             }),

package/dist/rules/interactive-supports-focus.js

@@ -38,7 +38,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     defaultOptions: [{ allowList: DEFAULT_ALLOW_LIST }],
     create(context, [{ allowList }]) {
         return {
-            Element$1(node) {
+            Element(node) {
                 const elementType = node.name;
                 if (!(0, get_dom_elements_1.getDomElements)().has(elementType)) {
                     return;

package/dist/rules/label-has-associated-control.js

@@ -77,7 +77,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         let inputItems = [];
         let labelItems = [];
         return {
-            [`Element$1`](node) {
+            [`Element`](node) {
                 if (allControlComponents.has(node.name)) {
                     inputItems.push(node);
                 }

package/dist/rules/mouse-events-have-key-events.js

@@ -39,7 +39,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         ];
         return eventPairs.reduce((accumulator, [keyEvent, mouseEvent]) => ({
             ...accumulator,
-            [`Element$1[name=${domElementsPattern}]:has(BoundEvent[name='${mouseEvent}']):not(:has(BoundEvent[name='${keyEvent}']))`]({ sourceSpan, }) {
+            [`Element[name=${domElementsPattern}]:has(BoundEvent[name='${mouseEvent}']):not(:has(BoundEvent[name='${keyEvent}']))`]({ sourceSpan, }) {
                 const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
                 context.report({
                     loc,

package/dist/rules/no-autofocus.js

@@ -24,7 +24,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         const elementNamePattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()]);
         return {
-            [`Element$1[name=${elementNamePattern}] > :matches(BoundAttribute, TextAttribute)[name="autofocus"]`]({ sourceSpan, }) {
+            [`Element[name=${elementNamePattern}] > :matches(BoundAttribute, TextAttribute)[name="autofocus"]`]({ sourceSpan, }) {
                 const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
                 context.report({
                     loc,

package/dist/rules/no-distracting-elements.js

@@ -21,7 +21,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     create(context) {
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         return {
-            'Element$1[name=/^(blink|marquee)$/]'({ name: element, sourceSpan, }) {
+            'Element[name=/^(blink|marquee)$/]'({ name: element, sourceSpan, }) {
                 const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
                 context.report({
                     loc,

package/dist/rules/no-duplicate-attributes.js

@@ -52,7 +52,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     create(context, [{ allowTwoWayDataBinding, allowStylePrecedenceDuplicates, ignore }]) {
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         return {
-            Element$1({ inputs, outputs, attributes }) {
+            Element({ inputs, outputs, attributes }) {
                 // According to the Angular documentation (https://angular.dev/guide/templates/class-binding#styling-precedence)
                 // Angular merges both attributes which means their combined use can be seen as valid
                 const angularStylePrecedenceDuplicatesAllowed = ['class', 'style'];

package/dist/rules/no-inline-styles.js

@@ -39,7 +39,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     create(context, [{ allowNgStyle, allowBindToStyle }]) {
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         return {
-            Element$1(node) {
+            Element(node) {
                 let isInvalid = false;
                 if (!allowNgStyle && !allowBindToStyle) {
                     isInvalid =

package/dist/rules/no-interpolation-in-attributes.js

@@ -19,7 +19,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     create(context) {
         const sourceCode = context.sourceCode;
         return {
-            ['BoundAttribute Interpolation$1'](interpolation) {
+            ['BoundAttribute Interpolation'](interpolation) {
                 const { sourceSpan: { start, end }, } = interpolation;
                 context.report({
                     loc: {

package/dist/rules/no-positive-tabindex.js

@@ -25,7 +25,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         const elementNamePattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()]);
         return {
-            [`Element$1[name=${elementNamePattern}] > BoundAttribute[name="tabindex"][value.ast.value>0], TextAttribute[name="tabindex"][value>0]`]({ valueSpan, }) {
+            [`Element[name=${elementNamePattern}] > BoundAttribute[name="tabindex"][value.ast.value>0], TextAttribute[name="tabindex"][value>0]`]({ valueSpan, }) {
                 const loc = parserServices.convertNodeSourceSpanToLoc(valueSpan);
                 context.report({
                     loc,

package/dist/rules/prefer-contextual-for-variables.d.ts

@@ -0,0 +1,17 @@
+export type Options = [
+    {
+        readonly allowedAliases?: {
+            $count?: readonly string[];
+            $index?: readonly string[];
+            $first?: readonly string[];
+            $last?: readonly string[];
+            $even?: readonly string[];
+            $odd?: readonly string[];
+        };
+    }
+];
+export type MessageIds = 'preferContextualVariable' | 'preferCount' | 'preferFirst' | 'preferLast' | 'preferEven' | 'preferOdd';
+export declare const RULE_NAME = "prefer-contextual-for-variables";
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../utils/create-eslint-rule").RuleDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+export default _default;
+//# sourceMappingURL=prefer-contextual-for-variables.d.ts.map

package/dist/rules/prefer-contextual-for-variables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-contextual-for-variables.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-contextual-for-variables.ts"],"names":[],"mappings":"AAmBA,MAAM,MAAM,OAAO,GAAG;IACpB;QACE,QAAQ,CAAC,cAAc,CAAC,EAAE;YACxB,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC3B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC3B,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC3B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC1B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;YAC1B,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;SAC1B,CAAC;KACH;CACF,CAAC;AACF,MAAM,MAAM,UAAU,GAClB,0BAA0B,GAC1B,aAAa,GACb,aAAa,GACb,YAAY,GACZ,YAAY,GACZ,WAAW,CAAC;AAChB,eAAO,MAAM,SAAS,oCAAoC,CAAC;;AAc3D,wBAiaG"}

package/dist/rules/prefer-contextual-for-variables.js

@@ -0,0 +1,546 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const are_equivalent_asts_1 = require("../utils/are-equivalent-asts");
+exports.RULE_NAME = 'prefer-contextual-for-variables';
+const DEFAULT_OPTIONS = {
+    allowedAliases: {
+        $count: [],
+        $index: [],
+        $first: [],
+        $last: [],
+        $even: [],
+        $odd: [],
+    },
+};
+const EQUALITY_OPERATORS = ['===', '=='];
+const INEQUALITY_OPERATORS = ['!==', '!='];
+const LOGICAL_OPERATORS = ['&&', '||'];
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that contextual variables are used in @for blocks where possible instead of aliasing them.',
+        },
+        fixable: 'code',
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowedAliases: {
+                        type: 'object',
+                        properties: {
+                            $count: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Aliases for $count that are allowed to be used.',
+                            },
+                            $index: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Aliases for $index that are allowed to be used.',
+                            },
+                            $first: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Aliases for $first that are allowed to be used.',
+                            },
+                            $last: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Aliases for $last that are allowed to be used.',
+                            },
+                            $even: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Aliases for $even that are allowed to be used.',
+                            },
+                            $odd: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Aliases for $odd that are allowed to be used.',
+                            },
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            preferContextualVariable: "Use the '{{name}}' contextual variable instead of aliasing it.",
+            preferCount: "Use '$count' instead of '{{ expression }}'.",
+            preferFirst: "Use '$first' instead of '{{ expression }}'.",
+            preferLast: "Use '$last' instead of '{{ expression }}'.",
+            preferEven: "Use '$even' instead of '{{ expression }}'.",
+            preferOdd: "Use '$odd' instead of '{{ expression }}'.",
+        },
+    },
+    defaultOptions: [DEFAULT_OPTIONS],
+    create(context, [{ allowedAliases }]) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        const forLoops = [];
+        function reportSimplifications(messageId, forLoop) {
+            const simplifications = forLoop.simplifications?.[messageId];
+            if (!simplifications) {
+                return;
+            }
+            const sourceCode = context.sourceCode;
+            for (const simplification of simplifications) {
+                context.report({
+                    messageId,
+                    loc: {
+                        start: sourceCode.getLocFromIndex(simplification.range[0]),
+                        end: sourceCode.getLocFromIndex(simplification.range[1]),
+                    },
+                    data: {
+                        expression: context.sourceCode.text.slice(simplification.range[0], simplification.range[1]),
+                    },
+                    fix: (fixer) => fixer.replaceTextRange(simplification.range, simplification.replacement),
+                });
+            }
+        }
+        return {
+            ForLoopBlock(node) {
+                // We need to know if there are nested for loops before we
+                // can report any problems. When there are nested for loops,
+                // aliasing will be required to access the outer contextual
+                // variables from within the inner loop, so we won't report
+                // any problems when there are nested for loops.
+                const nested = forLoops.length > 0;
+                if (nested) {
+                    forLoops[forLoops.length - 1].canAlias = true;
+                }
+                // All contextual variables are defined, but
+                // only aliased variables have a value span.
+                const variables = node.contextVariables.filter((x) => x.valueSpan);
+                forLoops.push({
+                    canAlias: nested,
+                    source: node.expression.ast,
+                    variables,
+                    references: 
+                    // Don't bother creating a map of variable
+                    // references if there are no variables to track.
+                    variables.length > 0
+                        ? new Map(variables.map((variable) => [variable.name, []]))
+                        : undefined,
+                });
+            },
+            'ForLoopBlock:exit'() {
+                const forLoop = forLoops.pop();
+                if (!forLoop) {
+                    return;
+                }
+                if (!forLoop.canAlias) {
+                    const problems = [];
+                    for (const [index, variable] of forLoop.variables.entries()) {
+                        const allowed = getAllowedAliases(allowedAliases, variable.value);
+                        if (allowed === undefined || !allowed.includes(variable.name)) {
+                            problems.push({
+                                index,
+                                variable,
+                                loc: parserServices.convertNodeSourceSpanToLoc(variable.sourceSpan),
+                            });
+                        }
+                    }
+                    for (const problem of problems) {
+                        context.report({
+                            messageId: 'preferContextualVariable',
+                            loc: problem.loc,
+                            data: { name: problem.variable.value },
+                            fix: function* (fixer) {
+                                yield fixer.removeRange(getVariableRangeToRemove(problem, context.sourceCode, forLoop.variables.length));
+                                // Replace any references to the alias
+                                // with the contextual variable name.
+                                const references = forLoop.references?.get(problem.variable.name);
+                                if (references) {
+                                    for (const reference of references) {
+                                        yield fixer.replaceTextRange(reference, problem.variable.value);
+                                    }
+                                }
+                            },
+                        });
+                    }
+                }
+                if (forLoop.simplifications) {
+                    reportSimplifications('preferCount', forLoop);
+                    reportSimplifications('preferFirst', forLoop);
+                    reportSimplifications('preferLast', forLoop);
+                    reportSimplifications('preferEven', forLoop);
+                    reportSimplifications('preferOdd', forLoop);
+                }
+            },
+            PropertyRead(node) {
+                // Get the information for the inner-most for loop (which will be
+                // the last one in the array) so that we can record the usage of
+                // aliases and expressions using contextual variables that can be
+                // simplified. We only need the inner-most for loop because we
+                // don't remove aliases when there are nested for loops (meaning
+                // we don't need to record alias usage for the outer for loop), and
+                // any contextual variables will only reference the inner most loop.
+                const forLoop = forLoops.at(-1);
+                if (!forLoop) {
+                    return;
+                }
+                // Record any references to aliased variables so
+                // that we can replace them if we remove the alias.
+                forLoop.references
+                    ?.get(node.name)
+                    ?.push([node.sourceSpan.start, node.sourceSpan.end]);
+                // If the `length` property is being read from the same
+                // value that was used as the source of the for loop, then
+                // we can simplify that to just use the `$count` variable.
+                if (node.name === 'length' &&
+                    (0, are_equivalent_asts_1.areEquivalentASTs)(node.receiver, forLoop.source)) {
+                    recordSimplification(node, forLoop, 'preferCount', '$count');
+                }
+            },
+            Binary(node) {
+                const forLoop = forLoops.at(-1);
+                if (!forLoop) {
+                    return;
+                }
+                if (isIndex(node.left)) {
+                    if (isZero(node.right)) {
+                        if (EQUALITY_OPERATORS.includes(node.operation)) {
+                            // `$index === 0` can be simplified to `$first`.
+                            recordSimplification(node, forLoop, 'preferFirst', '$first');
+                        }
+                        else if (INEQUALITY_OPERATORS.includes(node.operation) ||
+                            node.operation === '>') {
+                            // `$index !== 0` or `$index > 0` can be simplified to `!$first`.
+                            recordSimplification(node, forLoop, 'preferFirst', '!$first');
+                        }
+                    }
+                    else if (isCountMinusOne(node.right)) {
+                        if (EQUALITY_OPERATORS.includes(node.operation)) {
+                            // `$index === ($count - 1)` can be simplified to `$last`.
+                            recordSimplification(node, forLoop, 'preferLast', '$last');
+                        }
+                        else if (INEQUALITY_OPERATORS.includes(node.operation) ||
+                            node.operation === '<') {
+                            // `$index !== ($count - 1)` or `$index < ($count - 1)`
+                            // can be simplified to `!$last`.
+                            recordSimplification(node, forLoop, 'preferLast', '!$last');
+                        }
+                    }
+                }
+                else if (isZero(node.left)) {
+                    if (isIndex(node.right)) {
+                        if (EQUALITY_OPERATORS.includes(node.operation)) {
+                            // `0 === $index` can be simplified to `$first`.
+                            recordSimplification(node, forLoop, 'preferFirst', '$first');
+                        }
+                        else if (INEQUALITY_OPERATORS.includes(node.operation) ||
+                            node.operation === '<') {
+                            // `0 !== $index` or `0 < $index` can be simplified to `!$first`.
+                            recordSimplification(node, forLoop, 'preferFirst', '!$first');
+                        }
+                    }
+                    else if (isIndexModTwo(node.right)) {
+                        if (EQUALITY_OPERATORS.includes(node.operation)) {
+                            // `0 == ($index % 2)` can be simplified to `$even`.
+                            recordSimplification(node, forLoop, 'preferEven', '$even');
+                        }
+                        else if (INEQUALITY_OPERATORS.includes(node.operation) ||
+                            node.operation === '<') {
+                            // `0 !== ($index % 2)` or `0 < ($index % 2)`
+                            // can be simplified to `$odd`.
+                            recordSimplification(node, forLoop, 'preferOdd', '$odd');
+                        }
+                    }
+                }
+                else if (isOne(node.left)) {
+                    if (isIndexModTwo(node.right)) {
+                        if (EQUALITY_OPERATORS.includes(node.operation)) {
+                            // `1 === ($index % 2)` can be simplified to `$odd`.
+                            recordSimplification(node, forLoop, 'preferOdd', '$odd');
+                        }
+                        else if (INEQUALITY_OPERATORS.includes(node.operation) ||
+                            node.operation === '>') {
+                            // `1 !== ($index % 2)` or `1 > ($index % 2)`
+                            // can be simplified to `$even`.
+                            recordSimplification(node, forLoop, 'preferEven', '$even');
+                        }
+                    }
+                }
+                else if (isCount(node.left)) {
+                    if (isIndexPlusOne(node.right)) {
+                        if (EQUALITY_OPERATORS.includes(node.operation)) {
+                            // `$count === ($index + 1)` can be simplified to `$last`.
+                            recordSimplification(node, forLoop, 'preferLast', '$last');
+                        }
+                        else if (INEQUALITY_OPERATORS.includes(node.operation) ||
+                            node.operation === '>') {
+                            // `$count !== ($index + 1)` or `$count > ($index + 1)`
+                            // can be simplified to `!$last`.
+                            recordSimplification(node, forLoop, 'preferLast', '!$last');
+                        }
+                    }
+                }
+                else if (isIndexPlusOne(node.left)) {
+                    if (isCount(node.right)) {
+                        if (EQUALITY_OPERATORS.includes(node.operation)) {
+                            // `($index + 1) === $count` can be simplified to `$last`.
+                            recordSimplification(node, forLoop, 'preferLast', '$last');
+                        }
+                        else if (INEQUALITY_OPERATORS.includes(node.operation) ||
+                            node.operation === '<') {
+                            // `($index + 1) !== $count` or `($index + 1) < $count`
+                            // can be simplified to `!$last`.
+                            recordSimplification(node, forLoop, 'preferLast', '!$last');
+                        }
+                    }
+                }
+                else if (isCountMinusOne(node.left)) {
+                    if (isIndex(node.right)) {
+                        if (EQUALITY_OPERATORS.includes(node.operation)) {
+                            // `($count - 1) === $index` can be simplified to `$last`.
+                            recordSimplification(node, forLoop, 'preferLast', '$last');
+                        }
+                        else if (INEQUALITY_OPERATORS.includes(node.operation) ||
+                            node.operation === '>') {
+                            // `($count - 1) !== $index` or `($count - 1) > $index`
+                            // can be simplified to `!$last`.
+                            recordSimplification(node, forLoop, 'preferLast', '!$last');
+                        }
+                    }
+                }
+                else if (isIndexModTwo(node.left)) {
+                    if (isZero(node.right)) {
+                        if (EQUALITY_OPERATORS.includes(node.operation)) {
+                            // `($index % 2) === 0` can be simplified to `$even`.
+                            recordSimplification(node, forLoop, 'preferEven', '$even');
+                        }
+                        else if (INEQUALITY_OPERATORS.includes(node.operation) ||
+                            node.operation === '>') {
+                            // `($index % 2) !== 0` or `($index % 2) > 0`
+                            // can be simplified to `$odd`.
+                            recordSimplification(node, forLoop, 'preferOdd', '$odd');
+                        }
+                    }
+                    else if (isOne(node.right)) {
+                        if (EQUALITY_OPERATORS.includes(node.operation)) {
+                            // `($index % 2) === 1` can be simplified to `$odd`.
+                            recordSimplification(node, forLoop, 'preferOdd', '$odd');
+                        }
+                        else if (INEQUALITY_OPERATORS.includes(node.operation) ||
+                            node.operation === '<') {
+                            // `($index % 2) !== 1` or `($index % 2) < 1`
+                            // can be simplified to `$even`.
+                            recordSimplification(node, forLoop, 'preferEven', '$even');
+                        }
+                    }
+                    else if (LOGICAL_OPERATORS.includes(node.operation)) {
+                        // `$index % 2` can be used to test if `$index` is odd, but it
+                        // results in a number, so we can only simplify it when it is
+                        // being used as a truthy value. Because it's on the left-hand
+                        // side of a logical binary expression, we can simplify it.
+                        recordSimplification(node.left, forLoop, 'preferOdd', '$odd');
+                    }
+                }
+                if (isIndexModTwo(node.right) &&
+                    LOGICAL_OPERATORS.includes(node.operation)) {
+                    // As we did with the left-hand side above, when `$index % 2`
+                    // is used as a truthy value on the right-hand side
+                    // of a logical binary expression, we can simplify it.
+                    recordSimplification(node.right, forLoop, 'preferOdd', '$odd');
+                }
+            },
+            PrefixNot(node) {
+                const forLoop = forLoops.at(-1);
+                if (!forLoop) {
+                    return;
+                }
+                if (isOdd(node.expression) || isIndexModTwo(node.expression)) {
+                    // `!$odd` or `!($index % 2)` can be simplified to `$even`.
+                    recordSimplification(node, forLoop, 'preferEven', '$even');
+                }
+                else if (isEven(node.expression)) {
+                    // `!$even` can be simplified to `$odd`.
+                    recordSimplification(node, forLoop, 'preferOdd', '$odd');
+                }
+            },
+            Conditional(node) {
+                const forLoop = forLoops.at(-1);
+                if (!forLoop) {
+                    return;
+                }
+                // If the condition is `$index % 2`, then it's being
+                // used as a truthy value and we can simplify it.
+                if (isIndexModTwo(node.condition)) {
+                    recordSimplification(node.condition, forLoop, 'preferOdd', '$odd');
+                }
+            },
+            IfBlockBranch(node) {
+                const forLoop = forLoops.at(-1);
+                if (!forLoop) {
+                    return;
+                }
+                // If the expression is `$index % 2`, then it's being
+                // used as a truthy value and we can simplify it.
+                if (node.expression) {
+                    let expression = node.expression;
+                    if (expression instanceof bundled_angular_compiler_1.ASTWithSource) {
+                        expression = expression.ast;
+                    }
+                    if (isIndexModTwo(expression)) {
+                        recordSimplification(expression, forLoop, 'preferOdd', '$odd');
+                    }
+                }
+            },
+        };
+    },
+});
+function getAllowedAliases(allowedAliases, variableName) {
+    if (allowedAliases && variableName in allowedAliases) {
+        return allowedAliases[variableName];
+    }
+    return undefined;
+}
+function getVariableRangeToRemove(problem, sourceCode, variableCount) {
+    let start = problem.variable.sourceSpan.start.offset;
+    let end = problem.variable.sourceSpan.end.offset;
+    if (variableCount === 1) {
+        // There's only one variable defined, so we
+        // want to remove the `let` keyword as well.
+        const letIndex = getStartOfPreviousToken('let', start, sourceCode);
+        if (letIndex !== undefined) {
+            // We also want to remove the preceding semicolon.
+            start = getStartOfPreviousToken(';', letIndex, sourceCode) ?? letIndex;
+        }
+    }
+    else if (problem.index === 0) {
+        // There are multiple variables, but we're removing
+        // the first one. We need to keep the `let` keyword, but
+        // remove the trailing comma and any whitespace after it.
+        const commaIndex = getStartOfNextToken(',', end, sourceCode);
+        if (commaIndex !== undefined) {
+            // The range to remove is end-exclusive, so we
+            // need to add one to remove the comma.
+            end = getIndexOfNextNonWhitespace(commaIndex + 1, sourceCode);
+        }
+    }
+    else {
+        // There is a variable before this one, so we
+        // need to remove the preceding comma as well.
+        start = getStartOfPreviousToken(',', start, sourceCode) ?? start;
+    }
+    return [start, end];
+}
+function getStartOfPreviousToken(tokenToFind, startIndex, sourceCode) {
+    const text = sourceCode.text;
+    for (let i = startIndex - tokenToFind.length; i >= 0; i--) {
+        if (text.slice(i, i + tokenToFind.length) === tokenToFind) {
+            return i;
+        }
+    }
+    return undefined;
+}
+function getStartOfNextToken(tokenToFind, startIndex, sourceCode) {
+    const text = sourceCode.text;
+    for (let i = startIndex; i < text.length; i++) {
+        if (text.slice(i, i + tokenToFind.length) === tokenToFind) {
+            return i;
+        }
+    }
+    return undefined;
+}
+function getIndexOfNextNonWhitespace(startIndex, sourceCode) {
+    const text = sourceCode.text;
+    let index = startIndex;
+    while (index < text.length) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        if (!/\s/.test(text.at(index))) {
+            return index;
+        }
+        index++;
+    }
+    return text.length;
+}
+function recordSimplification(node, forLoop, type, replacement) {
+    // Most of the time we won't find anything to simplify because
+    // we would have simplified everything on the previous passes,
+    // so we delay-create this to reduce memory allocations.
+    if (!forLoop.simplifications) {
+        forLoop.simplifications = {};
+    }
+    let nodes = forLoop.simplifications[type];
+    if (!nodes) {
+        nodes = [];
+        forLoop.simplifications[type] = nodes;
+    }
+    nodes.push({
+        range: [node.sourceSpan.start, node.sourceSpan.end],
+        replacement,
+    });
+}
+function isIndex(node) {
+    return isContextualVariable(node, '$index');
+}
+function isIndexPlusOne(node) {
+    if (node instanceof bundled_angular_compiler_1.Binary) {
+        if (node.operation === '+') {
+            if (isIndex(node.left)) {
+                return isOne(node.right);
+            }
+            else {
+                return isIndex(node.right) && isOne(node.left);
+            }
+        }
+    }
+    return false;
+}
+function isIndexModTwo(node) {
+    return (node instanceof bundled_angular_compiler_1.Binary &&
+        node.operation === '%' &&
+        isIndex(node.left) &&
+        isTwo(node.right));
+}
+function isCount(node) {
+    return isContextualVariable(node, '$count');
+}
+function isCountMinusOne(node) {
+    if (node instanceof bundled_angular_compiler_1.Binary) {
+        if (node.operation === '-') {
+            if (isCount(node.left)) {
+                return isOne(node.right);
+            }
+            else {
+                return isCount(node.right) && isOne(node.left);
+            }
+        }
+    }
+    return false;
+}
+function isEven(node) {
+    return isContextualVariable(node, '$even');
+}
+function isOdd(node) {
+    return isContextualVariable(node, '$odd');
+}
+function isContextualVariable(node, name) {
+    return (node instanceof bundled_angular_compiler_1.PropertyRead &&
+        node.name === name &&
+        // The contextual variable must be accessed implicitly.
+        // That is, `this.$index` is not a contextual variable.
+        // Note that `ThisReceiver` extends `ImplicitReceiver`, so we
+        // need to check that the receiver is exactly an `ImplicitReceiver`
+        // and not just an instance of `ImplicitReceiver`.
+        node.receiver.constructor === bundled_angular_compiler_1.ImplicitReceiver);
+}
+function isZero(node) {
+    return isLiteralNumber(node, 0);
+}
+function isOne(node) {
+    return isLiteralNumber(node, 1);
+}
+function isTwo(node) {
+    return isLiteralNumber(node, 2);
+}
+function isLiteralNumber(node, value) {
+    return node instanceof bundled_angular_compiler_1.LiteralPrimitive && node.value === value;
+}

package/dist/rules/prefer-ngsrc.js

@@ -22,7 +22,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
     create(context) {
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         return {
-            'Element$1[name=img]'(element) {
+            'Element[name=img]'(element) {
                 const ngSrcAttribute = hasNgSrcAttribute(element);
                 const srcAttribute = hasNormalSrcAttribute(element);
                 if (!srcAttribute ||

package/dist/rules/prefer-self-closing-tags.js

@@ -28,7 +28,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
             return {};
         }
         return {
-            'Element$1, Template, Content'(node) {
+            'Element, Template, Content'(node) {
                 if (isContentNode(node)) {
                     processContentNode(node);
                 }

package/dist/rules/role-has-required-aria.js

@@ -27,7 +27,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         const elementNamePattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()]);
         return {
-            [`Element$1[name=${elementNamePattern}] > TextAttribute[name='role']`](node) {
+            [`Element[name=${elementNamePattern}] > TextAttribute[name='role']`](node) {
                 const { value: role, sourceSpan } = node;
                 const { attributes, inputs, name: element } = node.parent;
                 const props = [...attributes, ...inputs];

package/dist/rules/table-scope.js

@@ -24,7 +24,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         const domElementsPattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()].filter((domElement) => domElement !== 'th'));
         return {
-            [`Element$1[name=${domElementsPattern}] > :matches(BoundAttribute, TextAttribute)[name='scope']`]({ sourceSpan, }) {
+            [`Element[name=${domElementsPattern}] > :matches(BoundAttribute, TextAttribute)[name='scope']`]({ sourceSpan, }) {
                 const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
                 context.report({
                     loc,

package/dist/rules/valid-aria.js

@@ -28,7 +28,7 @@ exports.default = (0, create_eslint_rule_1.createESLintRule)({
         const parserServices = (0, utils_1.getTemplateParserServices)(context);
         const elementNamePattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()]);
         return {
-            [`Element$1[name=${elementNamePattern}] > :matches(BoundAttribute, TextAttribute)[name=/^aria-.+/]`](node) {
+            [`Element[name=${elementNamePattern}] > :matches(BoundAttribute, TextAttribute)[name=/^aria-.+/]`](node) {
                 const { name: attribute, sourceSpan } = node;
                 const ariaPropertyDefinition = aria_query_1.aria.get(attribute);
                 const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);

package/dist/utils/are-equivalent-asts.d.ts

@@ -0,0 +1,3 @@
+import { AST } from '@angular-eslint/bundled-angular-compiler';
+export declare function areEquivalentASTs(a: AST, b: AST): boolean;
+//# sourceMappingURL=are-equivalent-asts.d.ts.map

package/dist/utils/are-equivalent-asts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"are-equivalent-asts.d.ts","sourceRoot":"","sources":["../../src/utils/are-equivalent-asts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EAuBJ,MAAM,0CAA0C,CAAC;AAElD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CA4JzD"}

package/dist/utils/are-equivalent-asts.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areEquivalentASTs = areEquivalentASTs;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+function areEquivalentASTs(a, b) {
+    // An `ImplicitReceiver` is equivalent to a `ThisReceiver` because
+    // `this.foo` and `foo` mean the same thing. A `ThisReceiver` extends
+    // `ImplicitReceiver` so before we check if the two ASTs are the same
+    // type, we can check if they are both some sort of `ImplicitReceiver`.
+    if (a instanceof bundled_angular_compiler_1.ImplicitReceiver) {
+        return b instanceof bundled_angular_compiler_1.ImplicitReceiver;
+    }
+    // Bail out if the two ASTs are not the same type.
+    if (a.constructor !== b.constructor) {
+        return false;
+    }
+    // Check reads and calls first, because
+    // they are probably the most common type.
+    if (a instanceof bundled_angular_compiler_1.PropertyRead && b instanceof bundled_angular_compiler_1.PropertyRead) {
+        return a.name === b.name && areEquivalentASTs(a.receiver, b.receiver);
+    }
+    if (a instanceof bundled_angular_compiler_1.SafePropertyRead && b instanceof bundled_angular_compiler_1.SafePropertyRead) {
+        return a.name === b.name && areEquivalentASTs(a.receiver, b.receiver);
+    }
+    if (a instanceof bundled_angular_compiler_1.Call && b instanceof bundled_angular_compiler_1.Call) {
+        return (areEquivalentASTArrays(a.args, b.args) &&
+            areEquivalentASTs(a.receiver, b.receiver));
+    }
+    if (a instanceof bundled_angular_compiler_1.SafeCall && b instanceof bundled_angular_compiler_1.SafeCall) {
+        return (areEquivalentASTArrays(a.args, b.args) &&
+            areEquivalentASTs(a.receiver, b.receiver));
+    }
+    if (a instanceof bundled_angular_compiler_1.KeyedRead && b instanceof bundled_angular_compiler_1.KeyedRead) {
+        return (areEquivalentASTs(a.key, b.key) &&
+            areEquivalentASTs(a.receiver, b.receiver));
+    }
+    if (a instanceof bundled_angular_compiler_1.SafeKeyedRead && b instanceof bundled_angular_compiler_1.SafeKeyedRead) {
+        return (areEquivalentASTs(a.key, b.key) &&
+            areEquivalentASTs(a.receiver, b.receiver));
+    }
+    if (a instanceof bundled_angular_compiler_1.NonNullAssert && b instanceof bundled_angular_compiler_1.NonNullAssert) {
+        return areEquivalentASTs(a.expression, b.expression);
+    }
+    // Expressions used as conditions can come next.
+    if (a instanceof bundled_angular_compiler_1.PrefixNot && b instanceof bundled_angular_compiler_1.PrefixNot) {
+        return areEquivalentASTs(a.expression, b.expression);
+    }
+    // Unary extends Binary, so we need to check `Unary`
+    // first, otherwise we will treat it as a `Binary`.
+    if (a instanceof bundled_angular_compiler_1.Unary && b instanceof bundled_angular_compiler_1.Unary) {
+        return a.operator === b.operator && areEquivalentASTs(a.expr, b.expr);
+    }
+    if (a instanceof bundled_angular_compiler_1.Binary && b instanceof bundled_angular_compiler_1.Binary) {
+        return (a.operation === b.operation &&
+            areEquivalentASTs(a.left, b.left) &&
+            areEquivalentASTs(a.right, b.right));
+    }
+    if (a instanceof bundled_angular_compiler_1.Conditional && b instanceof bundled_angular_compiler_1.Conditional) {
+        return (areEquivalentASTs(a.condition, b.condition) &&
+            areEquivalentASTs(a.trueExp, b.trueExp) &&
+            areEquivalentASTs(a.falseExp, b.falseExp));
+    }
+    // Literals can be checked next.
+    if (a instanceof bundled_angular_compiler_1.LiteralPrimitive && b instanceof bundled_angular_compiler_1.LiteralPrimitive) {
+        return a.value === b.value;
+    }
+    if (a instanceof bundled_angular_compiler_1.LiteralArray && b instanceof bundled_angular_compiler_1.LiteralArray) {
+        return areEquivalentASTArrays(a.expressions, b.expressions);
+    }
+    if (a instanceof bundled_angular_compiler_1.LiteralMap && b instanceof bundled_angular_compiler_1.LiteralMap) {
+        return (a.keys.length === b.keys.length &&
+            // Only check that the keys are equivalent. We don't need to check
+            // the `quoted` property because a quoted key with the same value as
+            // an unquoted key is the same key. Likewise, the `isShorthandInitialized`
+            // property doesn't affect the name of the key.
+            a.keys.every((aKey, index) => aKey.key === b.keys[index].key) &&
+            areEquivalentASTArrays(a.values, b.values));
+    }
+    // Pipes and interpolations are next.
+    if (a instanceof bundled_angular_compiler_1.BindingPipe && b instanceof bundled_angular_compiler_1.BindingPipe) {
+        return (a.name === b.name &&
+            areEquivalentASTs(a.exp, b.exp) &&
+            areEquivalentASTArrays(a.args, b.args));
+    }
+    if (a instanceof bundled_angular_compiler_1.Interpolation && b instanceof bundled_angular_compiler_1.Interpolation) {
+        return (a.strings.length === b.strings.length &&
+            a.strings.every((aString, index) => aString === b.strings[index]) &&
+            areEquivalentASTArrays(a.expressions, b.expressions));
+    }
+    // Miscellaneous things and writes can be checked next.
+    if (a instanceof bundled_angular_compiler_1.ASTWithSource && b instanceof bundled_angular_compiler_1.ASTWithSource) {
+        return areEquivalentASTs(a.ast, b.ast);
+    }
+    if (a instanceof bundled_angular_compiler_1.Chain && b instanceof bundled_angular_compiler_1.Chain) {
+        return areEquivalentASTArrays(a.expressions, b.expressions);
+    }
+    if (a instanceof bundled_angular_compiler_1.PropertyWrite && b instanceof bundled_angular_compiler_1.PropertyWrite) {
+        return (a.name === b.name &&
+            areEquivalentASTs(a.receiver, b.receiver) &&
+            areEquivalentASTs(a.value, b.value));
+    }
+    if (a instanceof bundled_angular_compiler_1.KeyedWrite && b instanceof bundled_angular_compiler_1.KeyedWrite) {
+        return (areEquivalentASTs(a.key, b.key) &&
+            areEquivalentASTs(a.receiver, b.receiver) &&
+            areEquivalentASTs(a.value, b.value));
+    }
+    if (a instanceof bundled_angular_compiler_1.TypeofExpression && b instanceof bundled_angular_compiler_1.TypeofExpression) {
+        return areEquivalentASTs(a.expression, b.expression);
+    }
+    return false;
+}
+function areEquivalentASTArrays(a, b) {
+    return (a.length === b.length &&
+        a.every((aElement, index) => areEquivalentASTs(aElement, b[index])));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-eslint/eslint-plugin-template",
-  "version": "19.2.2-alpha.4",
+  "version": "19.2.2-alpha.6",
   "description": "ESLint plugin for Angular Templates",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,13 +20,13 @@
   "dependencies": {
     "aria-query": "5.3.2",
     "axobject-query": "4.1.0",
-    "@angular-eslint/utils": "19.2.2-alpha.4",
-    "@angular-eslint/bundled-angular-compiler": "19.2.2-alpha.4"
+    "@angular-eslint/bundled-angular-compiler": "19.2.2-alpha.6",
+    "@angular-eslint/utils": "19.2.2-alpha.6"
   },
   "devDependencies": {
     "@types/aria-query": "5.0.4",
-    "@angular-eslint/template-parser": "19.2.2-alpha.4",
-    "@angular-eslint/test-utils": "19.2.2-alpha.4"
+    "@angular-eslint/template-parser": "19.2.2-alpha.6",
+    "@angular-eslint/test-utils": "19.2.2-alpha.6"
   },
   "peerDependencies": {
     "@typescript-eslint/types": "^7.11.0 || ^8.0.0",