@taiga-ui/eslint-plugin-experience-next 0.474.0 → 0.476.0

package/index.esm.js

@@ -898,6 +898,7 @@ var recommended = defineConfig([
             ],
             '@taiga-ui/experience-next/host-attributes-sort': 'error',
             '@taiga-ui/experience-next/injection-token-description': 'error',
+            '@taiga-ui/experience-next/no-commonjs-import-patterns': 'error',
             '@taiga-ui/experience-next/no-deep-imports': [
                 'error',
                 {
@@ -908,6 +909,8 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-deep-imports-to-indexed-packages': 'error',
             '@taiga-ui/experience-next/no-fully-untracked-effect': 'error',
             '@taiga-ui/experience-next/no-implicit-public': 'error',
+            '@taiga-ui/experience-next/no-import-assertions': 'error',
+            '@taiga-ui/experience-next/no-infinite-loop': 'error',
             '@taiga-ui/experience-next/no-redundant-type-annotation': 'error',
             '@taiga-ui/experience-next/no-side-effects-in-computed': 'error',
             '@taiga-ui/experience-next/no-signal-reads-after-await-in-reactive-context': 'error',
@@ -916,6 +919,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/object-single-line': ['error', { printWidth: 90 }],
             '@taiga-ui/experience-next/prefer-combined-if-control-flow': 'error',
             '@taiga-ui/experience-next/prefer-multi-arg-push': 'error',
+            '@taiga-ui/experience-next/prefer-namespace-keyword': 'error',
             '@taiga-ui/experience-next/prefer-untracked-incidental-signal-reads': 'error',
             '@taiga-ui/experience-next/prefer-untracked-signal-getter': 'error',
             '@taiga-ui/experience-next/short-tui-imports': 'error',
@@ -1299,6 +1303,11 @@ const config$4 = {
     },
 };
 
+function intersect(a, b) {
+    const origin = new Set(b);
+    return a.some((type) => origin.has(type));
+}
+
 function getFieldTypes(type, checker) {
     const typeNames = [];
     if (type.isUnionOrIntersection()) {
@@ -1331,16 +1340,24 @@ function getFieldTypes(type, checker) {
     return typeNames;
 }
 
-function intersect(a, b) {
-    const origin = new Set(b);
-    return a.some((type) => origin.has(type));
+function getTypeAwareRuleContext(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const { sourceCode } = context;
+    return {
+        checker: parserServices.program.getTypeChecker(),
+        esTreeNodeToTSNodeMap: parserServices.esTreeNodeToTSNodeMap,
+        parserServices,
+        program: sourceCode.ast,
+        sourceCode,
+        tsNodeToESTreeNodeMap: parserServices.tsNodeToESTreeNodeMap,
+        tsProgram: parserServices.program,
+    };
 }
 
-const createRule$i = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$i({
+const createRule$m = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$m({
     create(context, [configs]) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const typeChecker = parserServices.program.getTypeChecker();
+        const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const flatConfig = configs.flat();
         return {
             PropertyDefinition(node) {
@@ -1348,7 +1365,7 @@ var classPropertyNaming = createRule$i({
                 if (!fieldName) {
                     return;
                 }
-                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                const tsNode = esTreeNodeToTSNodeMap.get(node);
                 const nodeType = typeChecker.getTypeAtLocation(tsNode);
                 const fieldTypes = getFieldTypes(nodeType, typeChecker);
                 const rule = flatConfig.find((rule) => intersect(fieldTypes, rule.withTypesSpecifier) &&
@@ -1404,6 +1421,10 @@ var classPropertyNaming = createRule$i({
     name: 'class-property-naming',
 });
 
+function sameOrder(a, b) {
+    return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+
 const config$3 = {
     create(context) {
         const order = context.options[0] || {};
@@ -1422,7 +1443,7 @@ const config$3 = {
                                 .map((prop) => prop.key?.name)
                                 .filter(Boolean);
                             const correct = getCorrectOrderRelative(orderList, current);
-                            if (!isCorrectSortedAccording(correct, current)) {
+                            if (!sameOrder(correct, current.filter((item) => correct.includes(item)))) {
                                 context.report({
                                     fix: (fixer) => {
                                         const fileContent = context.sourceCode.text;
@@ -1458,10 +1479,6 @@ const config$3 = {
         type: 'problem',
     },
 };
-function isCorrectSortedAccording(correct, current) {
-    return (JSON.stringify(correct) ===
-        JSON.stringify(current.filter((item) => correct.includes(item))));
-}
 function getCorrectOrderRelative(correct, current) {
     return correct.filter((item) => current.includes(item));
 }
@@ -1506,12 +1523,11 @@ function isExternalPureTuple(typeChecker, type) {
     return typeArgs.every((item) => isClassType(item));
 }
 
-const createRule$h = ESLintUtils.RuleCreator((name) => name);
+const createRule$l = ESLintUtils.RuleCreator((name) => name);
 const MESSAGE_ID$7 = 'spreadArrays';
-var flatExports = createRule$h({
+var flatExports = createRule$l({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const typeChecker = parserServices.program.getTypeChecker();
+        const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const arrays = new Map();
         const purityCache = new WeakMap();
         const isPureArray = (arr) => {
@@ -1595,7 +1611,7 @@ var flatExports = createRule$h({
                         isDirty = true;
                         continue;
                     }
-                    const tsNode = parserServices.esTreeNodeToTSNodeMap.get(el);
+                    const tsNode = esTreeNodeToTSNodeMap.get(el);
                     const elType = typeChecker.getTypeAtLocation(tsNode);
                     const isClass = isClassType(elType);
                     const isArrayLike = typeChecker.isArrayLikeType(elType) ||
@@ -1675,8 +1691,53 @@ function getDecoratorMetadata(decorator, allowedNames) {
     return isObject(arg) ? arg : null;
 }
 
-function sameOrder(a, b) {
-    return a.length === b.length && a.every((value, index) => value === b[index]);
+function isStringLiteral(node) {
+    return node?.type === AST_NODE_TYPES.Literal && typeof node.value === 'string';
+}
+function isStaticTemplateLiteral(node) {
+    return (node?.type === AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1);
+}
+function getStaticStringValue(node) {
+    if (isStringLiteral(node)) {
+        return node.value;
+    }
+    if (!isStaticTemplateLiteral(node)) {
+        return null;
+    }
+    return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? '';
+}
+function isEmptyStaticString(node) {
+    return getStaticStringValue(node) === '';
+}
+
+function getStaticPropertyName(key) {
+    if (key.type === AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    if (key.type === AST_NODE_TYPES.Literal &&
+        (typeof key.value === 'string' || typeof key.value === 'number')) {
+        return String(key.value);
+    }
+    return getStaticStringValue(key);
+}
+function getObjectPropertyName(node) {
+    if (node.computed) {
+        return null;
+    }
+    return getStaticPropertyName(node.key);
+}
+function getMemberExpressionPropertyName(node) {
+    if (!node.computed && node.property.type === AST_NODE_TYPES.Identifier) {
+        return node.property.name;
+    }
+    return node.computed ? getStaticStringValue(node.property) : null;
+}
+function getClassMemberName(member) {
+    return member.key.type === AST_NODE_TYPES.PrivateIdentifier
+        ? null
+        : getStaticPropertyName(member.key);
 }
 
 const DEFAULT_GROUP = '$DEFAULT';
@@ -1744,8 +1805,8 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const createRule$g = ESLintUtils.RuleCreator((name) => name);
-const rule$j = createRule$g({
+const createRule$k = ESLintUtils.RuleCreator((name) => name);
+const rule$n = createRule$k({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -1867,21 +1928,6 @@ function getHostAttributeProperties(hostObject) {
     }
     return properties;
 }
-function getStaticPropertyName(key) {
-    if (key.type === AST_NODE_TYPES$1.Identifier) {
-        return key.name;
-    }
-    if (key.type === AST_NODE_TYPES$1.Literal &&
-        (typeof key.value === 'string' || typeof key.value === 'number')) {
-        return String(key.value);
-    }
-    if (key.type === AST_NODE_TYPES$1.TemplateLiteral &&
-        key.expressions.length === 0 &&
-        key.quasis.length === 1) {
-        return key.quasis[0]?.value.cooked ?? null;
-    }
-    return null;
-}
 function organizeProperties(properties, options) {
     const groups = getGroups(options.attributeGroups.length > 0 ? options.attributeGroups : ['$ANGULAR'], options.attributeIgnoreCase);
     const defaultGroup = ensureDefaultGroup(groups);
@@ -2021,7 +2067,7 @@ const config$2 = {
 const MESSAGE_ID$5 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
 const NG_DEV_MODE = 'ngDevMode';
-const createRule$f = ESLintUtils.RuleCreator((name) => name);
+const createRule$j = ESLintUtils.RuleCreator((name) => name);
 function getVariableName(node) {
     if (node.parent.type !== AST_NODE_TYPES$1.VariableDeclarator) {
         return undefined;
@@ -2029,21 +2075,18 @@ function getVariableName(node) {
     const { id } = node.parent;
     return id.type === AST_NODE_TYPES$1.Identifier ? id.name : undefined;
 }
-function isStringLiteral$1(node) {
-    return node.type === AST_NODE_TYPES$1.Literal && typeof node.value === 'string';
-}
 function isStringLike(node) {
-    return isStringLiteral$1(node) || node.type === AST_NODE_TYPES$1.TemplateLiteral;
+    return isStringLiteral(node) || node.type === AST_NODE_TYPES$1.TemplateLiteral;
 }
 function getStringValue(node) {
-    if (isStringLiteral$1(node)) {
+    if (isStringLiteral(node)) {
         return node.value;
     }
     return node.quasis[0]?.value.raw || '';
 }
-function isEmptyString$1(node) {
-    return (getStringValue(node) === '' &&
-        (!('expressions' in node) || !node.expressions.length));
+function isEmptyString(node) {
+    return (isEmptyStaticString(node) &&
+        (!('expressions' in node) || node.expressions.length === 0));
 }
 function isNgDevModeConditional(node) {
     return (node.type === AST_NODE_TYPES$1.ConditionalExpression &&
@@ -2051,7 +2094,7 @@ function isNgDevModeConditional(node) {
         node.test.name === NG_DEV_MODE &&
         isStringLike(node.consequent) &&
         isStringLike(node.alternate) &&
-        isEmptyString$1(node.alternate));
+        isEmptyString(node.alternate));
 }
 function getDescriptionValue(node) {
     if (isStringLike(node)) {
@@ -2092,7 +2135,7 @@ function getNgDevModeDeclarationFix(program, fixer) {
     }
     return fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
 }
-const rule$i = createRule$f({
+const rule$m = createRule$j({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -2141,6 +2184,88 @@ const rule$i = createRule$f({
     name: 'injection-token-description',
 });
 
+const createRule$i = ESLintUtils.RuleCreator((name) => name);
+function getResolvedVariable(sourceCode, node) {
+    const scope = sourceCode.getScope(node);
+    const reference = scope.references.find((item) => item.identifier === node);
+    return reference?.resolved ?? null;
+}
+const rule$l = createRule$i({
+    create(context) {
+        const { sourceCode } = context;
+        const namespaceImports = new Map();
+        const markNamespaceImportAsUsedLikeValue = (identifier) => {
+            const usage = namespaceImports.get(identifier.name);
+            if (!usage ||
+                usage.usedLikeValue ||
+                getResolvedVariable(sourceCode, identifier) !== usage.variable) {
+                return;
+            }
+            usage.usedLikeValue = true;
+        };
+        return {
+            'CallExpression > Identifier.callee'(node) {
+                markNamespaceImportAsUsedLikeValue(node);
+            },
+            ImportDeclaration(node) {
+                const namespaceImport = node.specifiers.find((specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier);
+                if (!namespaceImport) {
+                    return;
+                }
+                const [variable] = sourceCode.getDeclaredVariables(namespaceImport);
+                if (!variable) {
+                    return;
+                }
+                namespaceImports.set(namespaceImport.local.name, {
+                    node: namespaceImport,
+                    usedLikeValue: false,
+                    variable,
+                });
+            },
+            'NewExpression > Identifier.callee'(node) {
+                markNamespaceImportAsUsedLikeValue(node);
+            },
+            'Program:exit'() {
+                for (const usage of namespaceImports.values()) {
+                    if (!usage.usedLikeValue) {
+                        continue;
+                    }
+                    context.report({
+                        data: { name: usage.node.local.name },
+                        messageId: 'avoidCallableNamespaceImport',
+                        node: usage.node,
+                    });
+                }
+            },
+            'TaggedTemplateExpression > Identifier.tag'(node) {
+                markNamespaceImportAsUsedLikeValue(node);
+            },
+            TSImportEqualsDeclaration(node) {
+                if (node.moduleReference.type !== AST_NODE_TYPES.TSExternalModuleReference) {
+                    return;
+                }
+                context.report({
+                    data: { name: node.id.name },
+                    messageId: 'avoidImportEquals',
+                    node,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow legacy CommonJS interop import patterns such as `import = require(...)` and namespace imports used like callable values.',
+        },
+        messages: {
+            avoidCallableNamespaceImport: 'Namespace import "{{name}}" is used like a value instead of a namespace. This is a brittle interop pattern and often should become a default import.',
+            avoidImportEquals: '`import {{name}} = require(...)` is a legacy CommonJS import pattern.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-commonjs-import-patterns',
+});
+
 const MESSAGE_ID$4 = 'no-deep-imports';
 const ERROR_MESSAGE$2 = 'Deep imports of Taiga UI packages are prohibited';
 const CODE_EXTENSIONS = new Set([
@@ -2160,8 +2285,8 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const createRule$e = ESLintUtils.RuleCreator((name) => name);
-const rule$h = createRule$e({
+const createRule$h = ESLintUtils.RuleCreator((name) => name);
+const rule$k = createRule$h({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -2248,13 +2373,13 @@ const rule$h = createRule$e({
     name: 'no-deep-imports',
 });
 
-const createRule$d = ESLintUtils.RuleCreator((name) => name);
+const createRule$g = ESLintUtils.RuleCreator((name) => name);
 const resolveCacheByOptions = new WeakMap();
 const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-var noDeepImportsToIndexedPackages = createRule$d({
+var noDeepImportsToIndexedPackages = createRule$g({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -2443,63 +2568,13 @@ function stripKnownExtensions(filePathOrSpecifier) {
     return filePathOrSpecifier.replace(/\.(?:d\.ts|ts|tsx|js|jsx|mjs|cjs)$/, '');
 }
 
-const ANGULAR_CORE$1 = '@angular/core';
-/**
- * Returns the local name bound to a named import from a given source.
- * Handles aliased imports: `import { untracked as ngUntracked } from '@angular/core'`
- * returns `'ngUntracked'` for `exportedName = 'untracked'`.
- */
-function getLocalNameForImport(program, source, exportedName) {
-    for (const node of program.body) {
-        if (node.type !== AST_NODE_TYPES.ImportDeclaration ||
-            node.source.value !== source) {
-            continue;
-        }
-        for (const spec of node.specifiers) {
-            if (spec.type !== AST_NODE_TYPES.ImportSpecifier) {
-                continue;
-            }
-            const imported = spec.imported.type === AST_NODE_TYPES.Identifier
-                ? spec.imported.name
-                : spec.imported.value;
-            if (imported === exportedName) {
-                return spec.local.name;
-            }
-        }
-    }
-    return null;
-}
-function findAngularCoreImports(program) {
-    return program.body.filter((node) => node.type === AST_NODE_TYPES.ImportDeclaration &&
-        node.source.value === ANGULAR_CORE$1);
-}
-function findRuntimeAngularCoreImport(program) {
-    return (findAngularCoreImports(program).find((node) => node.importKind !== 'type') ?? null);
-}
-function findAngularCoreImportSpecifier(program, exportedName) {
-    for (const importDecl of findAngularCoreImports(program)) {
-        for (const specifier of importDecl.specifiers) {
-            if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) {
-                continue;
-            }
-            const imported = specifier.imported.type === AST_NODE_TYPES.Identifier
-                ? specifier.imported.name
-                : specifier.imported.value;
-            if (imported === exportedName) {
-                return { importDecl, specifier };
-            }
-        }
-    }
-    return null;
-}
-
-function isFunctionLike$1(node) {
+function isFunctionLike(node) {
     return (node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
         node.type === AST_NODE_TYPES.FunctionDeclaration ||
         node.type === AST_NODE_TYPES.FunctionExpression);
 }
 function getOrderedChildren(node) {
-    if (isFunctionLike$1(node)) {
+    if (isFunctionLike(node)) {
         const children = [
             ...node.params,
             node.body,
@@ -2568,7 +2643,7 @@ function getOrderedChildren(node) {
 function walkSynchronousAst(root, visitor) {
     traverse(root, true);
     function traverse(node, isRoot = false) {
-        if (visitor(node) === false || (!isRoot && isFunctionLike$1(node))) {
+        if (visitor(node) === false || (!isRoot && isFunctionLike(node))) {
             return false;
         }
         if (node.type === AST_NODE_TYPES.AwaitExpression) {
@@ -2597,7 +2672,7 @@ function walkAfterAsyncBoundaryAst(root, visitor) {
         if (afterBoundary) {
             visitor(node);
         }
-        if (!isRoot && isFunctionLike$1(node)) {
+        if (!isRoot && isFunctionLike(node)) {
             return false;
         }
         if (node.type === AST_NODE_TYPES.AwaitExpression) {
@@ -2660,6 +2735,56 @@ function walkAst(root, visitor) {
     }
 }
 
+const ANGULAR_CORE$1 = '@angular/core';
+/**
+ * Returns the local name bound to a named import from a given source.
+ * Handles aliased imports: `import { untracked as ngUntracked } from '@angular/core'`
+ * returns `'ngUntracked'` for `exportedName = 'untracked'`.
+ */
+function getLocalNameForImport(program, source, exportedName) {
+    for (const node of program.body) {
+        if (node.type !== AST_NODE_TYPES.ImportDeclaration ||
+            node.source.value !== source) {
+            continue;
+        }
+        for (const spec of node.specifiers) {
+            if (spec.type !== AST_NODE_TYPES.ImportSpecifier) {
+                continue;
+            }
+            const imported = spec.imported.type === AST_NODE_TYPES.Identifier
+                ? spec.imported.name
+                : spec.imported.value;
+            if (imported === exportedName) {
+                return spec.local.name;
+            }
+        }
+    }
+    return null;
+}
+function findAngularCoreImports(program) {
+    return program.body.filter((node) => node.type === AST_NODE_TYPES.ImportDeclaration &&
+        node.source.value === ANGULAR_CORE$1);
+}
+function findRuntimeAngularCoreImport(program) {
+    return (findAngularCoreImports(program).find((node) => node.importKind !== 'type') ?? null);
+}
+function findAngularCoreImportSpecifier(program, exportedName) {
+    for (const importDecl of findAngularCoreImports(program)) {
+        for (const specifier of importDecl.specifiers) {
+            if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) {
+                continue;
+            }
+            const imported = specifier.imported.type === AST_NODE_TYPES.Identifier
+                ? specifier.imported.name
+                : specifier.imported.value;
+            if (imported === exportedName) {
+                return { importDecl, specifier };
+            }
+        }
+    }
+    return null;
+}
+
 const ANGULAR_CORE = '@angular/core';
 const SIGNAL_WRITE_METHODS = new Set(['mutate', 'set', 'update']);
 const AFTER_RENDER_EFFECT_PHASES = new Map([
@@ -2668,10 +2793,14 @@ const AFTER_RENDER_EFFECT_PHASES = new Map([
     ['read', 'afterRenderEffect().read'],
     ['write', 'afterRenderEffect().write'],
 ]);
-function isReactiveCallback$1(node) {
+function isReactiveCallback(node) {
     return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
         node?.type === AST_NODE_TYPES.FunctionExpression);
 }
+function getReactiveCallbackArgument(node) {
+    const [arg] = node.arguments;
+    return isReactiveCallback(arg) ? arg : null;
+}
 function getPropertyName(property) {
     if (property.computed) {
         return null;
@@ -2691,11 +2820,11 @@ function isAngularCoreCall(node, program, exportedName) {
         node.arguments.length >= 1);
 }
 function appendFirstArgReactiveScope(scopes, call, kind) {
-    const [arg] = call.arguments;
-    if (!isReactiveCallback$1(arg)) {
+    const callback = getReactiveCallbackArgument(call);
+    if (!callback) {
         return;
     }
-    scopes.push({ callback: arg, kind, owner: call, reportNode: call });
+    scopes.push({ callback, kind, owner: call, reportNode: call });
 }
 function appendObjectPropertyReactiveScopes(scopes, call, object, labels) {
     for (const property of object.properties) {
@@ -2704,7 +2833,7 @@ function appendObjectPropertyReactiveScopes(scopes, call, object, labels) {
         }
         const name = getPropertyName(property);
         const label = name ? labels.get(name) : null;
-        if (!label || !isReactiveCallback$1(property.value)) {
+        if (!label || !isReactiveCallback(property.value)) {
             continue;
         }
         scopes.push({
@@ -2914,54 +3043,74 @@ function collectSignalUsages(scopeNode, checker, esTreeNodeToTSNodeMap, program)
     });
     return { reads, writes };
 }
-
-const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#reading-without-tracking-dependencies';
-const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
-const UNTRACKED_RULES_README_URL = 'https://github.com/taiga-family/taiga-ui/blob/main/projects/eslint-plugin-experience-next/README.md';
-const createUntrackedRule = ESLintUtils.RuleCreator((name) => `${UNTRACKED_RULES_README_URL}#${name}`);
-
-/**
- * Collects signal reads that appear inside `untracked(...)` callbacks within
- * `root`, without descending into nested `untracked(...)` scopes.
- */
-function collectReadsInsideUntracked(root, checker, esTreeNodeToTSNodeMap, program) {
+function collectSignalReadsInsideUntracked(root, checker, esTreeNodeToTSNodeMap, program) {
     const reads = [];
     walkSynchronousAst(root, (node) => {
         if (node.type !== AST_NODE_TYPES.CallExpression ||
             !isAngularUntrackedCall(node, program)) {
             return;
         }
-        const [arg] = node.arguments;
-        if (!arg ||
-            (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-                arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+        const callback = getReactiveCallbackArgument(node);
+        if (!callback) {
             return false;
         }
-        walkSynchronousAst(arg, (inner) => {
+        walkSynchronousAst(callback, (inner) => {
             if (inner.type === AST_NODE_TYPES.CallExpression &&
                 isSignalReadCall(inner, checker, esTreeNodeToTSNodeMap)) {
                 reads.push(inner);
             }
         });
-        return false; // Do not descend into nested untracked from the outer walk
+        return false;
     });
     return reads;
 }
-const rule$g = createUntrackedRule({
+function isReactiveOwnerCall(node, program) {
+    return (node.type === AST_NODE_TYPES.CallExpression &&
+        getReactiveScopes(node, program).length > 0);
+}
+function getReturnedReactiveOwnerCall(node, program) {
+    const callback = getReactiveCallbackArgument(node);
+    if (!callback) {
+        return null;
+    }
+    if (isReactiveOwnerCall(callback.body, program)) {
+        return callback.body;
+    }
+    if (callback.body.type !== AST_NODE_TYPES.BlockStatement ||
+        callback.body.body.length !== 1) {
+        return null;
+    }
+    const [statement] = callback.body.body;
+    if (statement?.type === AST_NODE_TYPES.ReturnStatement &&
+        statement.argument &&
+        isReactiveOwnerCall(statement.argument, program)) {
+        return statement.argument;
+    }
+    if (node.parent.type === AST_NODE_TYPES.ExpressionStatement &&
+        statement?.type === AST_NODE_TYPES.ExpressionStatement &&
+        isReactiveOwnerCall(statement.expression, program)) {
+        return statement.expression;
+    }
+    return null;
+}
+
+const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#reading-without-tracking-dependencies';
+const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
+const UNTRACKED_RULES_README_URL = 'https://github.com/taiga-family/taiga-ui/blob/main/projects/eslint-plugin-experience-next/README.md';
+const createUntrackedRule = ESLintUtils.RuleCreator((name) => `${UNTRACKED_RULES_README_URL}#${name}`);
+
+const rule$j = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
+        const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
         return {
             CallExpression(node) {
                 for (const scope of getReactiveScopes(node, program)) {
-                    const { reads: trackedReads } = collectSignalUsages(scope.callback, checker, esTreeNodeToTSNodeMap, program);
+                    const { reads: trackedReads } = collectSignalUsages(scope.callback, checker, signalNodeMap, program);
                     if (trackedReads.length > 0) {
                         continue;
                     }
-                    const untrackedReads = collectReadsInsideUntracked(scope.callback, checker, esTreeNodeToTSNodeMap, program);
+                    const untrackedReads = collectSignalReadsInsideUntracked(scope.callback, checker, signalNodeMap, program);
                     if (untrackedReads.length === 0) {
                         continue;
                     }
@@ -3033,11 +3182,67 @@ const config$1 = {
     },
 };
 
-const createRule$c = ESLintUtils.RuleCreator((name) => name);
-const rule$f = createRule$c({
+function findAncestor(node, predicate) {
+    for (let current = node?.parent; current; current = current.parent) {
+        if (predicate(current)) {
+            return current;
+        }
+    }
+    return null;
+}
+function findSelfOrAncestor(node, predicate) {
+    for (let current = node; current; current = current.parent) {
+        if (predicate(current)) {
+            return current;
+        }
+    }
+    return null;
+}
+function hasAncestor(node, predicate) {
+    for (let current = node?.parent; current; current = current.parent) {
+        if (predicate(current)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isNodeInside(node, ancestor) {
+    for (let current = node; current; current = current.parent) {
+        if (current === ancestor) {
+            return true;
+        }
+    }
+    return false;
+}
+function isNodeInsideAny(node, ancestors) {
+    return ancestors.some((ancestor) => isNodeInside(node, ancestor));
+}
+function isClassLike(node) {
+    return (node.type === AST_NODE_TYPES.ClassDeclaration ||
+        node.type === AST_NODE_TYPES.ClassExpression);
+}
+function isClassMember(node) {
+    return (node.type === AST_NODE_TYPES.MethodDefinition ||
+        node.type === AST_NODE_TYPES.PropertyDefinition);
+}
+function getEnclosingFunction(node) {
+    return findAncestor(node, isFunctionLike);
+}
+function getEnclosingClass(node) {
+    return findSelfOrAncestor(node, isClassLike);
+}
+function getEnclosingClassMember(node) {
+    return findAncestor(node, isClassMember);
+}
+function getScopeRoot(node) {
+    return (findAncestor(node, (ancestor) => ancestor.type === AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
+}
+
+const createRule$f = ESLintUtils.RuleCreator((name) => name);
+const rule$i = createRule$f({
     create(context) {
         const checkImplicitPublic = (node) => {
-            const classRef = getClass(node);
+            const classRef = getEnclosingClass(node);
             if (!classRef ||
                 node.kind === 'constructor' ||
                 !!node?.accessibility ||
@@ -3095,19 +3300,114 @@ const rule$f = createRule$c({
     },
     name: 'explicit-public-member',
 });
-function getClass(node) {
-    if (!node) {
-        return null;
+
+const createRule$e = ESLintUtils.RuleCreator((name) => name);
+const rule$h = createRule$e({
+    create(context) {
+        const { sourceCode } = context;
+        return {
+            ImportDeclaration(node) {
+                const importAttributesToken = sourceCode.getTokenAfter(node.source);
+                if (importAttributesToken?.value !== 'assert') {
+                    return;
+                }
+                context.report({
+                    fix: (fixer) => fixer.replaceText(importAttributesToken, 'with'),
+                    messageId: 'useWithImportAttributes',
+                    node: importAttributesToken,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow legacy `assert { ... }` import assertions. Use `with { ... }` import attributes instead.',
+        },
+        fixable: 'code',
+        messages: {
+            useWithImportAttributes: 'Use `with { ... }` import attributes instead of `assert { ... }`.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-import-assertions',
+});
+
+function getParenthesizedInner(node) {
+    const maybeNode = node;
+    if (maybeNode.type === 'ParenthesizedExpression') {
+        return maybeNode.expression ?? null;
     }
-    if (node.type === AST_NODE_TYPES.ClassDeclaration) {
-        return node;
+    return null;
+}
+function unwrapParenthesized(node) {
+    let current = node;
+    let inner = getParenthesizedInner(current);
+    while (inner) {
+        current = inner;
+        inner = getParenthesizedInner(current);
     }
-    return getClass(node.parent);
+    return current;
 }
 
-const createRule$b = ESLintUtils.RuleCreator((name) => name);
+const createRule$d = ESLintUtils.RuleCreator((name) => name);
+function isInfiniteLoopLiteral(node) {
+    const unwrapped = unwrapParenthesized(node);
+    if (unwrapped.type !== AST_NODE_TYPES.Literal) {
+        return false;
+    }
+    return unwrapped.value === true || unwrapped.value === 1;
+}
+function isInfiniteLoopTest(test) {
+    return test === null || isInfiniteLoopLiteral(test);
+}
+const rule$g = createRule$d({
+    create(context) {
+        return {
+            DoWhileStatement(node) {
+                if (isInfiniteLoopTest(node.test)) {
+                    context.report({
+                        messageId: 'doWhileLoop',
+                        node: node.test,
+                    });
+                }
+            },
+            ForStatement(node) {
+                if (isInfiniteLoopTest(node.test)) {
+                    context.report({
+                        messageId: 'forLoop',
+                        node,
+                    });
+                }
+            },
+            WhileStatement(node) {
+                if (isInfiniteLoopTest(node.test)) {
+                    context.report({
+                        messageId: 'whileLoop',
+                        node: node.test,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow `for (;;)` / conditionals `for`, `while (true)`, and `do ... while (true)`. Prefer loops with meaningful exit conditions.',
+        },
+        messages: {
+            doWhileLoop: 'Use an explicit exit condition instead of `do ... while (true)`.',
+            forLoop: 'Use an explicit exit condition instead of a `for` loop without a condition.',
+            whileLoop: 'Use an explicit exit condition instead of `while (true)`.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'no-infinite-loop',
+});
+
+const createRule$c = ESLintUtils.RuleCreator((name) => name);
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$e = createRule$b({
+const rule$f = createRule$c({
     create(context) {
         return {
             Program(node) {
@@ -3145,11 +3445,10 @@ const rule$e = createRule$b({
     name: 'no-legacy-peer-deps',
 });
 
-const createRule$a = ESLintUtils.RuleCreator((name) => name);
-const rule$d = createRule$a({
+const createRule$b = ESLintUtils.RuleCreator((name) => name);
+const rule$e = createRule$b({
     create(context) {
-        const services = ESLintUtils.getParserServices(context);
-        const checker = services.program.getTypeChecker();
+        const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         return {
             CallExpression(node) {
                 const callee = node.callee;
@@ -3163,18 +3462,18 @@ const rule$d = createRule$a({
                     return;
                 }
                 const [argument] = node.arguments;
-                if (!argument || !isEmptyString(argument)) {
+                if (!argument || !isEmptyStaticString(argument)) {
                     return;
                 }
                 const objectExpression = callee.object;
-                const tsNode = services.esTreeNodeToTSNodeMap.get(objectExpression);
+                const tsNode = esTreeNodeToTSNodeMap.get(objectExpression);
                 const type = checker.getTypeAtLocation(tsNode);
                 if (!isPlaywrightLocator(type, checker)) {
                     return;
                 }
                 context.report({
                     fix(fixer) {
-                        const objectText = context.sourceCode.getText(objectExpression);
+                        const objectText = sourceCode.getText(objectExpression);
                         return fixer.replaceText(node, `${objectText}.clear()`);
                     },
                     messageId: 'useClear',
@@ -3194,13 +3493,6 @@ const rule$d = createRule$a({
     },
     name: 'no-playwright-empty-fill',
 });
-function isEmptyString(node) {
-    return ((node.type === AST_NODE_TYPES$1.Literal && node.value === '') ||
-        (node.type === AST_NODE_TYPES$1.TemplateLiteral &&
-            node.expressions.length === 0 &&
-            node.quasis.length === 1 &&
-            node.quasis[0]?.value.cooked === ''));
-}
 function isPlaywrightLocator(type, checker) {
     if (isPlaywrightLocatorType(type)) {
         return true;
@@ -3311,7 +3603,7 @@ const config = {
     },
 };
 
-const createRule$9 = ESLintUtils.RuleCreator((name) => name);
+const createRule$a = ESLintUtils.RuleCreator((name) => name);
 function collectArrayExpressions(node) {
     const result = [];
     if (node.type === AST_NODE_TYPES.ArrayExpression) {
@@ -3337,17 +3629,16 @@ function collectArrayExpressions(node) {
     }
     return result;
 }
-const rule$c = createRule$9({
+const rule$d = createRule$a({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const typeChecker = parserServices.program.getTypeChecker();
+        const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const ignoreTupleContextualTyping = context.options[0]?.ignoreTupleContextualTyping ?? true;
         function check(node, typeAnnotation, value) {
             if (!typeAnnotation || !value) {
                 return;
             }
-            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-            const tsValueNode = parserServices.esTreeNodeToTSNodeMap.get(value);
+            const tsNode = esTreeNodeToTSNodeMap.get(node);
+            const tsValueNode = esTreeNodeToTSNodeMap.get(value);
             const declaredType = typeChecker.getTypeAtLocation(tsNode);
             const inferredType = typeChecker.getTypeAtLocation(tsValueNode);
             if (typeChecker.typeToString(declaredType) !==
@@ -3371,7 +3662,7 @@ const rule$c = createRule$9({
             if (ignoreTupleContextualTyping) {
                 const arrayExpressions = collectArrayExpressions(value);
                 for (const arrayExpression of arrayExpressions) {
-                    const tsArrayNode = parserServices.esTreeNodeToTSNodeMap.get(arrayExpression);
+                    const tsArrayNode = esTreeNodeToTSNodeMap.get(arrayExpression);
                     if (typeChecker.isTupleType(typeChecker.getTypeAtLocation(tsArrayNode))) {
                         return;
                     }
@@ -3465,16 +3756,6 @@ function unwrapExpression(expression) {
     return current;
 }
 
-const createRule$8 = ESLintUtils.RuleCreator((name) => name);
-function isFunctionLikeScope(node) {
-    return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-        node?.type === AST_NODE_TYPES.FunctionDeclaration ||
-        node?.type === AST_NODE_TYPES.FunctionExpression);
-}
-function isReactiveCallback(node) {
-    return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-        node?.type === AST_NODE_TYPES.FunctionExpression);
-}
 function unwrapMutationTarget(node) {
     let current = node;
     while (current.type === AST_NODE_TYPES.TSAsExpression ||
@@ -3508,6 +3789,7 @@ function collectMutationTargets(node) {
             return [];
     }
 }
+
 function getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap) {
     const tsNode = esTreeNodeToTSNodeMap.get(node);
     if (!tsNode) {
@@ -3515,6 +3797,11 @@ function getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap) {
     }
     return checker.getSymbolAtLocation(tsNode) ?? null;
 }
+
+const createRule$9 = ESLintUtils.RuleCreator((name) => name);
+function isFunctionLikeScope(node) {
+    return !!node && isFunctionLike(node);
+}
 function isLocalIdentifier(node, context, localScopes) {
     const symbol = getSymbolAtNode(node, context.checker, context.esTreeNodeToTSNodeMap);
     if (!symbol) {
@@ -3671,9 +3958,9 @@ function functionHasObservableSideEffects(root, context, localScopes, visitedFun
                 return false;
             }
             if (isAngularUntrackedCall(node, context.program)) {
-                const [arg] = node.arguments;
-                if (isReactiveCallback(arg) &&
-                    functionHasObservableSideEffects(arg, context, [...localScopes, arg], visitedFunctions)) {
+                const callback = getReactiveCallbackArgument(node);
+                if (callback &&
+                    functionHasObservableSideEffects(callback, context, [...localScopes, callback], visitedFunctions)) {
                     hasSideEffect = true;
                 }
                 return false;
@@ -3727,9 +4014,9 @@ function inspectComputedBody(root, context, localScopes, visitedFunctions, repor
                 return false;
             }
             if (isAngularUntrackedCall(node, context.program)) {
-                const [arg] = node.arguments;
-                if (isReactiveCallback(arg)) {
-                    inspectComputedBody(arg, context, [...localScopes, arg], visitedFunctions, report);
+                const callback = getReactiveCallbackArgument(node);
+                if (callback) {
+                    inspectComputedBody(callback, context, [...localScopes, callback], visitedFunctions, report);
                 }
                 return false;
             }
@@ -3768,14 +4055,11 @@ function inspectComputedBody(root, context, localScopes, visitedFunctions, repor
         return;
     });
 }
-const rule$b = createRule$8({
+const rule$c = createRule$9({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const tsNodeToESTreeNodeMap = parserServices.tsNodeToESTreeNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
+        const estreeNodeMap = tsNodeToESTreeNodeMap;
         return {
             CallExpression(node) {
                 for (const scope of getReactiveScopes(node, program)) {
@@ -3784,10 +4068,10 @@ const rule$b = createRule$8({
                     }
                     const analysisContext = {
                         checker,
-                        esTreeNodeToTSNodeMap,
+                        esTreeNodeToTSNodeMap: signalNodeMap,
                         program,
                         reported: new Set(),
-                        tsNodeToESTreeNodeMap,
+                        tsNodeToESTreeNodeMap: estreeNodeMap,
                     };
                     inspectComputedBody(scope.callback, analysisContext, [scope.callback], new Set([String(scope.callback.range)]), (reportNode) => {
                         context.report({
@@ -3814,13 +4098,10 @@ const rule$b = createRule$8({
     name: 'no-side-effects-in-computed',
 });
 
-const rule$a = createUntrackedRule({
+const rule$b = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
         return {
             CallExpression(node) {
                 for (const scope of getReactiveScopes(node, program)) {
@@ -3828,7 +4109,7 @@ const rule$a = createUntrackedRule({
                     walkAfterAsyncBoundaryAst(scope.callback, (inner) => {
                         if (inner.type !== AST_NODE_TYPES.CallExpression ||
                             isAngularUntrackedCall(inner, program) ||
-                            !isSignalReadCall(inner, checker, esTreeNodeToTSNodeMap)) {
+                            !isSignalReadCall(inner, checker, signalNodeMap)) {
                             return;
                         }
                         const key = String(inner.range);
@@ -3863,11 +4144,7 @@ const rule$a = createUntrackedRule({
     name: 'no-signal-reads-after-await-in-reactive-context',
 });
 
-const createRule$7 = ESLintUtils.RuleCreator((name) => name);
-function isStringLiteral(node) {
-    return (node.type === AST_NODE_TYPES.Literal &&
-        typeof node.value === 'string');
-}
+const createRule$8 = ESLintUtils.RuleCreator((name) => name);
 function collectParts(node) {
     if (node.type === AST_NODE_TYPES.BinaryExpression && node.operator === '+') {
         return [...collectParts(node.left), ...collectParts(node.right)];
@@ -3917,17 +4194,7 @@ function templateContent(template, renderExpr) {
         : ''}`)
         .join('');
 }
-function hasTemplateLiteralAncestor(node) {
-    let current = node.parent;
-    while (current != null) {
-        if (current.type === AST_NODE_TYPES.TemplateLiteral) {
-            return true;
-        }
-        current = current.parent;
-    }
-    return false;
-}
-const rule$9 = createRule$7({
+const rule$a = createRule$8({
     create(context) {
         const { sourceCode } = context;
         let parserServices = null;
@@ -3982,7 +4249,7 @@ const rule$9 = createRule$7({
                 }
                 // Nested inside a template but not direct child — would produce
                 // `${`${a}${b}`.method()}`, so skip
-                if (hasTemplateLiteralAncestor(node)) {
+                if (hasAncestor(node, (ancestor) => ancestor.type === AST_NODE_TYPES.TemplateLiteral)) {
                     return;
                 }
                 context.report({
@@ -4096,67 +4363,6 @@ function buildImportRemovalFixes(program, fixer, sourceCode) {
     return [fixer.remove(untrackedSpec)];
 }
 
-const IMPERATIVE_UNTRACKED_METHODS = new Set(['registerOnChange', 'writeValue']);
-function dedent$1(text, extraSpaces) {
-    if (extraSpaces <= 0) {
-        return text;
-    }
-    const prefix = ' '.repeat(extraSpaces);
-    return text
-        .split('\n')
-        .map((line) => (line.startsWith(prefix) ? line.slice(extraSpaces) : line))
-        .join('\n');
-}
-function isFunctionLike(node) {
-    return (node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-        node.type === AST_NODE_TYPES.FunctionDeclaration ||
-        node.type === AST_NODE_TYPES.FunctionExpression);
-}
-function getObjectPropertyName(node) {
-    if (node.computed) {
-        return null;
-    }
-    if (node.key.type === AST_NODE_TYPES.Identifier) {
-        return node.key.name;
-    }
-    return typeof node.key.value === 'string' ? node.key.value : null;
-}
-function getMemberExpressionPropertyName(node) {
-    if (!node.computed && node.property.type === AST_NODE_TYPES.Identifier) {
-        return node.property.name;
-    }
-    return node.property.type === AST_NODE_TYPES.Literal &&
-        typeof node.property.value === 'string'
-        ? node.property.value
-        : null;
-}
-function getEnclosingClassMember(node) {
-    for (let current = node.parent; current; current = current.parent) {
-        if (current.type === AST_NODE_TYPES.MethodDefinition ||
-            current.type === AST_NODE_TYPES.PropertyDefinition) {
-            return current;
-        }
-    }
-    return null;
-}
-function getEnclosingFunction(node) {
-    for (let current = node.parent; current; current = current.parent) {
-        if (isFunctionLike(current)) {
-            return current;
-        }
-    }
-    return null;
-}
-function getClassMemberName(member) {
-    if (member.key.type === AST_NODE_TYPES.Identifier) {
-        return member.key.name;
-    }
-    if (member.key.type === AST_NODE_TYPES.Literal &&
-        typeof member.key.value === 'string') {
-        return member.key.value;
-    }
-    return null;
-}
 function hasNamedDecorator(node, name) {
     return node.decorators.some((decorator) => {
         const expression = decorator.expression;
@@ -4168,68 +4374,75 @@ function hasNamedDecorator(node, name) {
             expression.callee.name === name);
     });
 }
+
 function isPipeTransformMember(member) {
     if (getClassMemberName(member) !== 'transform') {
         return false;
     }
-    return hasNamedDecorator(member.parent.parent, 'Pipe');
+    const ownerClass = getEnclosingClass(member);
+    return !!ownerClass && hasNamedDecorator(ownerClass, 'Pipe');
 }
-function hasAllowedImperativeAssignment(node) {
-    for (let current = node.parent; current; current = current.parent) {
-        if (!isFunctionLike(current)) {
-            continue;
-        }
-        const parent = current.parent;
-        if (parent.type === AST_NODE_TYPES.AssignmentExpression &&
-            parent.right === current &&
-            parent.left.type === AST_NODE_TYPES.MemberExpression) {
-            const memberName = getMemberExpressionPropertyName(parent.left);
-            if (memberName && IMPERATIVE_UNTRACKED_METHODS.has(memberName)) {
-                return true;
-            }
-        }
+
+function isAngularInjectionTokenFactoryFunction(fn, program) {
+    const parent = fn.parent;
+    const injectionTokenName = getLocalNameForImport(program, '@angular/core', 'InjectionToken');
+    if (!injectionTokenName ||
+        parent.type !== AST_NODE_TYPES.Property ||
+        getObjectPropertyName(parent) !== 'factory') {
+        return false;
     }
-    return false;
-}
-function isAllowedImperativeAngularContext(node) {
-    const member = getEnclosingClassMember(node);
-    const memberName = member ? getClassMemberName(member) : null;
-    return ((!!member &&
-        !!memberName &&
-        (IMPERATIVE_UNTRACKED_METHODS.has(memberName) ||
-            isPipeTransformMember(member))) ||
-        hasAllowedImperativeAssignment(node));
+    const objectExpression = parent.parent;
+    return (objectExpression.type === AST_NODE_TYPES.ObjectExpression &&
+        objectExpression.parent.type === AST_NODE_TYPES.NewExpression &&
+        objectExpression.parent.arguments.includes(objectExpression) &&
+        objectExpression.parent.callee.type === AST_NODE_TYPES.Identifier &&
+        objectExpression.parent.callee.name === injectionTokenName);
 }
-function isDirectCallbackArgument(fn) {
+function isAngularUseFactoryFunction(fn) {
     const parent = fn.parent;
-    if (fn.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-        fn.type !== AST_NODE_TYPES.FunctionExpression) {
+    if (parent.type !== AST_NODE_TYPES.Property ||
+        getObjectPropertyName(parent) !== 'useFactory') {
         return false;
     }
-    return ((parent.type === AST_NODE_TYPES.CallExpression ||
-        parent.type === AST_NODE_TYPES.NewExpression) &&
-        parent.arguments.includes(fn));
+    const objectExpression = parent.parent;
+    return (objectExpression.type === AST_NODE_TYPES.ObjectExpression &&
+        objectExpression.properties.some((property) => property.type === AST_NODE_TYPES.Property &&
+            getObjectPropertyName(property) === 'provide'));
 }
-function getScopeRoot(node) {
-    for (let current = node.parent; current; current = current.parent) {
-        if (current.type === AST_NODE_TYPES.Program || isFunctionLike(current)) {
-            return current;
-        }
+
+/**
+ * Removes `extraSpaces` leading spaces from every line of `text` that starts
+ * with at least that many spaces.
+ */
+function dedent(text, extraSpaces) {
+    if (extraSpaces <= 0) {
+        return text;
     }
-    return node;
+    const prefix = ' '.repeat(extraSpaces);
+    return text
+        .split('\n')
+        .map((line) => (line.startsWith(prefix) ? line.slice(extraSpaces) : line))
+        .join('\n');
+}
+
+function isDirectCallOrNewArgument(node) {
+    const parent = node.parent;
+    if (node.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+        node.type !== AST_NODE_TYPES.FunctionExpression) {
+        return false;
+    }
+    return ((parent.type === AST_NODE_TYPES.CallExpression ||
+        parent.type === AST_NODE_TYPES.NewExpression) &&
+        parent.arguments.includes(node));
 }
-function isStoredCallbackUsedAsArgument(fn, checker, esTreeNodeToTSNodeMap) {
+function isStoredFunctionUsedAsCallOrNewArgument(fn, checker, esTreeNodeToTSNodeMap) {
     const parent = fn.parent;
     if (parent.type !== AST_NODE_TYPES.VariableDeclarator ||
         parent.id.type !== AST_NODE_TYPES.Identifier) {
         return false;
     }
     const id = parent.id;
-    const tsNode = esTreeNodeToTSNodeMap.get(id);
-    if (!tsNode) {
-        return false;
-    }
-    const symbol = checker.getSymbolAtLocation(tsNode);
+    const symbol = getSymbolAtNode(id, checker, esTreeNodeToTSNodeMap);
     if (!symbol) {
         return false;
     }
@@ -4241,10 +4454,7 @@ function isStoredCallbackUsedAsArgument(fn, checker, esTreeNodeToTSNodeMap) {
             node.name !== id.name) {
             return;
         }
-        const referenceTsNode = esTreeNodeToTSNodeMap.get(node);
-        const referenceSymbol = referenceTsNode
-            ? checker.getSymbolAtLocation(referenceTsNode)
-            : null;
+        const referenceSymbol = getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap);
         if (referenceSymbol !== symbol) {
             return;
         }
@@ -4259,81 +4469,50 @@ function isStoredCallbackUsedAsArgument(fn, checker, esTreeNodeToTSNodeMap) {
     });
     return found;
 }
+
+const IMPERATIVE_UNTRACKED_METHODS = new Set(['registerOnChange', 'writeValue']);
+function hasAllowedImperativeAssignment(node) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+            current.type !== AST_NODE_TYPES.FunctionDeclaration &&
+            current.type !== AST_NODE_TYPES.FunctionExpression) {
+            continue;
+        }
+        const parent = current.parent;
+        if (parent.type === AST_NODE_TYPES.AssignmentExpression &&
+            parent.right === current &&
+            parent.left.type === AST_NODE_TYPES.MemberExpression) {
+            const memberName = getMemberExpressionPropertyName(parent.left);
+            if (memberName && IMPERATIVE_UNTRACKED_METHODS.has(memberName)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isAllowedImperativeAngularContext(node) {
+    const member = getEnclosingClassMember(node);
+    const memberName = member ? getClassMemberName(member) : null;
+    return ((!!member &&
+        !!memberName &&
+        (IMPERATIVE_UNTRACKED_METHODS.has(memberName) ||
+            isPipeTransformMember(member))) ||
+        hasAllowedImperativeAssignment(node));
+}
 function isAllowedDeferredCallbackContext(node, checker, esTreeNodeToTSNodeMap) {
-    const [arg] = node.arguments;
-    if (!arg ||
-        arg.type === AST_NODE_TYPES.SpreadElement ||
-        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+    if (!getReactiveCallbackArgument(node)) {
         return false;
     }
     const fn = getEnclosingFunction(node);
     if (!fn) {
         return false;
     }
-    return (isDirectCallbackArgument(fn) ||
-        isStoredCallbackUsedAsArgument(fn, checker, esTreeNodeToTSNodeMap));
-}
-function isAngularInjectionTokenFactoryFunction(fn, program) {
-    const parent = fn.parent;
-    const injectionTokenName = getLocalNameForImport(program, '@angular/core', 'InjectionToken');
-    if (!injectionTokenName ||
-        parent.type !== AST_NODE_TYPES.Property ||
-        getObjectPropertyName(parent) !== 'factory') {
-        return false;
-    }
-    const objectExpression = parent.parent;
-    return (objectExpression.type === AST_NODE_TYPES.ObjectExpression &&
-        objectExpression.parent.type === AST_NODE_TYPES.NewExpression &&
-        objectExpression.parent.arguments.includes(objectExpression) &&
-        objectExpression.parent.callee.type === AST_NODE_TYPES.Identifier &&
-        objectExpression.parent.callee.name === injectionTokenName);
-}
-function isAngularUseFactoryFunction(fn) {
-    const parent = fn.parent;
-    if (parent.type !== AST_NODE_TYPES.Property ||
-        getObjectPropertyName(parent) !== 'useFactory') {
-        return false;
-    }
-    const objectExpression = parent.parent;
-    return (objectExpression.type === AST_NODE_TYPES.ObjectExpression &&
-        objectExpression.properties.some((property) => property.type === AST_NODE_TYPES.Property &&
-            getObjectPropertyName(property) === 'provide'));
-}
-function isReactiveOwnerCall(node, program) {
-    return (node.type === AST_NODE_TYPES.CallExpression &&
-        getReactiveScopes(node, program).length > 0);
-}
-function getFixableReactiveCall(node, program) {
-    const [arg] = node.arguments;
-    if (!arg ||
-        arg.type === AST_NODE_TYPES.SpreadElement ||
-        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
-        return null;
-    }
-    if (isReactiveOwnerCall(arg.body, program)) {
-        return arg.body;
-    }
-    if (arg.body.type !== AST_NODE_TYPES.BlockStatement || arg.body.body.length !== 1) {
-        return null;
-    }
-    const [statement] = arg.body.body;
-    if (statement?.type === AST_NODE_TYPES.ReturnStatement &&
-        statement.argument &&
-        isReactiveOwnerCall(statement.argument, program)) {
-        return statement.argument;
-    }
-    if (node.parent.type === AST_NODE_TYPES.ExpressionStatement &&
-        statement?.type === AST_NODE_TYPES.ExpressionStatement &&
-        isReactiveOwnerCall(statement.expression, program)) {
-        return statement.expression;
-    }
-    return null;
+    return (isDirectCallOrNewArgument(fn) ||
+        isStoredFunctionUsedAsCallOrNewArgument(fn, checker, esTreeNodeToTSNodeMap));
 }
 function isAllowedLazyAngularFactoryContext(node, program) {
     const fn = getEnclosingFunction(node);
-    if (!fn || !getFixableReactiveCall(node, program)) {
+    if (!fn || !getReturnedReactiveOwnerCall(node, program)) {
         return false;
     }
     return (isAngularInjectionTokenFactoryFunction(fn, program) ||
@@ -4345,16 +4524,12 @@ function buildReactiveCallReplacement(outerUntrackedCall, reactiveCall, sourceCo
         outerUntrackedCall.parent.type !== AST_NODE_TYPES.ExpressionStatement) {
         return text;
     }
-    return dedent$1(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
+    return dedent(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
 }
-const rule$8 = createUntrackedRule({
+const rule$9 = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
-        const getUntrackedLocalName = () => findUntrackedAlias(program);
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
         function isUntrackedUsedElsewhere(localName, excludeNode) {
             let found = false;
             walkAst(program, (node) => {
@@ -4375,18 +4550,18 @@ const rule$8 = createUntrackedRule({
                     findEnclosingReactiveScope(node, program) ||
                     findEnclosingReactiveScopeAfterAsyncBoundary(node, program) ||
                     isAllowedImperativeAngularContext(node) ||
-                    isAllowedDeferredCallbackContext(node, checker, esTreeNodeToTSNodeMap) ||
+                    isAllowedDeferredCallbackContext(node, checker, signalNodeMap) ||
                     isAllowedLazyAngularFactoryContext(node, program)) {
                     return;
                 }
-                const reactiveCall = getFixableReactiveCall(node, program);
+                const reactiveCall = getReturnedReactiveOwnerCall(node, program);
                 context.report({
                     fix: reactiveCall
                         ? (fixer) => {
                             const fixes = [
                                 fixer.replaceText(node, buildReactiveCallReplacement(node, reactiveCall, sourceCode)),
                             ];
-                            const untrackedLocalName = getUntrackedLocalName();
+                            const untrackedLocalName = findUntrackedAlias(program);
                             const stillUsed = untrackedLocalName !== null &&
                                 isUntrackedUsedElsewhere(untrackedLocalName, node);
                             if (!stillUsed) {
@@ -4418,20 +4593,16 @@ const rule$8 = createUntrackedRule({
     name: 'no-untracked-outside-reactive-context',
 });
 
-/**
- * Removes `extraSpaces` leading spaces from every line of `text` that starts
- * with at least that many spaces.
- */
-function dedent(text, extraSpaces) {
-    if (extraSpaces <= 0) {
-        return text;
-    }
-    const prefix = ' '.repeat(extraSpaces);
-    return text
-        .split('\n')
-        .map((line) => (line.startsWith(prefix) ? line.slice(extraSpaces) : line))
-        .join('\n');
+function collectCallExpressions(root) {
+    const result = [];
+    walkAst(root, (node) => {
+        if (node.type === AST_NODE_TYPES.CallExpression) {
+            result.push(node);
+        }
+    });
+    return result;
 }
+
 /**
  * Builds the replacement text for the parent ExpressionStatement of an
  * `untracked(...)` call.
@@ -4443,13 +4614,11 @@ function dedent(text, extraSpaces) {
  * Returns null if the untracked argument is not a function expression.
  */
 function buildReplacement(untrackedCall, parentStatement, sourceCode) {
-    const [arg] = untrackedCall.arguments;
-    if (!arg ||
-        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+    const callback = getReactiveCallbackArgument(untrackedCall);
+    if (!callback) {
         return null;
     }
-    const { body } = arg;
+    const { body } = callback;
     if (body.type === AST_NODE_TYPES.BlockStatement) {
         const { body: stmts } = body;
         if (stmts.length === 0) {
@@ -4464,15 +4633,6 @@ function buildReplacement(untrackedCall, parentStatement, sourceCode) {
     // Expression body: arrow `() => expr` — just emit `expr;`
     return `${sourceCode.getText(body)};`;
 }
-function getAllCallExpressions(root) {
-    const result = [];
-    walkAst(root, (node) => {
-        if (node.type === AST_NODE_TYPES.CallExpression) {
-            result.push(node);
-        }
-    });
-    return result;
-}
 function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program) {
     let found = false;
     walkSynchronousAst(root, (node) => {
@@ -4494,29 +4654,23 @@ function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program
     });
     return found;
 }
-const rule$7 = createUntrackedRule({
+const rule$8 = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
-        const getUntrackedLocalName = () => getLocalNameForImport(program, '@angular/core', 'untracked');
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
         function isUntrackedUsedElsewhere(localName, excludeNode) {
-            return getAllCallExpressions(program).some((n) => n !== excludeNode &&
+            return collectCallExpressions(program).some((n) => n !== excludeNode &&
                 n.callee.type === AST_NODE_TYPES.Identifier &&
                 n.callee.name === localName);
         }
         function checkUntrackedCall(untrackedCall, kind) {
-            const [arg] = untrackedCall.arguments;
-            if (!arg ||
-                (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-                    arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+            const callback = getReactiveCallbackArgument(untrackedCall);
+            if (!callback) {
                 return;
             }
-            const { reads } = collectSignalUsages(arg, checker, esTreeNodeToTSNodeMap, program);
+            const { reads } = collectSignalUsages(callback, checker, signalNodeMap, program);
             if (reads.length > 0 ||
-                hasOpaqueSynchronousCalls(arg, checker, esTreeNodeToTSNodeMap, program)) {
+                hasOpaqueSynchronousCalls(callback, checker, signalNodeMap, program)) {
                 // Snapshot reads inside reactive callbacks are a valid Angular
                 // pattern even when the snapshot later influences branching.
                 return;
@@ -4534,7 +4688,7 @@ const rule$7 = createUntrackedRule({
                         if (replacement === null) {
                             return null;
                         }
-                        const untrackedLocalName = getUntrackedLocalName();
+                        const untrackedLocalName = findUntrackedAlias(program);
                         const stillUsed = untrackedLocalName !== null &&
                             isUntrackedUsedElsewhere(untrackedLocalName, untrackedCall);
                         const fixes = [fixer.replaceText(parentStmt, replacement)];
@@ -4582,8 +4736,8 @@ const rule$7 = createUntrackedRule({
     name: 'no-useless-untracked',
 });
 
-const createRule$6 = ESLintUtils.RuleCreator((name) => name);
-const rule$6 = createRule$6({
+const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+const rule$7 = createRule$7({
     create(context, [{ printWidth }]) {
         const sourceCode = context.sourceCode;
         const getLineEndIndex = (lineStartIndex) => {
@@ -4835,24 +4989,8 @@ const rule$6 = createRule$6({
     name: 'object-single-line',
 });
 
-const createRule$5 = ESLintUtils.RuleCreator((name) => name);
+const createRule$6 = ESLintUtils.RuleCreator((name) => name);
 const EMPTY_ARGUMENT = '__EMPTY_ARGUMENT__';
-function getParenthesizedInner(node) {
-    const maybeNode = node;
-    if (maybeNode.type === 'ParenthesizedExpression') {
-        return maybeNode.expression ?? null;
-    }
-    return null;
-}
-function unwrapParenthesized(node) {
-    let current = node;
-    let inner = getParenthesizedInner(current);
-    while (inner) {
-        current = inner;
-        inner = getParenthesizedInner(current);
-    }
-    return current;
-}
 function isSupportedControlFlowStatement(node) {
     return (node.type === AST_NODE_TYPES.BreakStatement ||
         node.type === AST_NODE_TYPES.ContinueStatement ||
@@ -4920,7 +5058,7 @@ function renderTest(node, sourceCode) {
     const text = sourceCode.getText(node);
     return needsParenthesesInOrChain(node) ? `(${text})` : text;
 }
-const rule$5 = createRule$5({
+const rule$6 = createRule$6({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -5000,8 +5138,8 @@ const rule$5 = createRule$5({
 
 const MESSAGE_ID$1 = 'prefer-deep-imports';
 const ERROR_MESSAGE = 'Import via root entry point is prohibited when nested entry points exist';
-const createRule$4 = ESLintUtils.RuleCreator(() => ERROR_MESSAGE);
-var preferDeepImports = createRule$4({
+const createRule$5 = ESLintUtils.RuleCreator(() => ERROR_MESSAGE);
+var preferDeepImports = createRule$5({
     create(context, [options]) {
         const allowedPackages = normalizeImportFilter(options.importFilter);
         const isStrictMode = options.strict ?? false;
@@ -5342,7 +5480,7 @@ function buildRewrittenImports(node, baseImportPath, symbolToEntryPoint) {
     return importStatements.join('\n');
 }
 
-const createRule$3 = ESLintUtils.RuleCreator((name) => name);
+const createRule$4 = ESLintUtils.RuleCreator((name) => name);
 function getPushCall(node) {
     if (node.expression.type !== AST_NODE_TYPES.CallExpression) {
         return null;
@@ -5357,7 +5495,7 @@ function getPushCall(node) {
     }
     return call;
 }
-const rule$4 = createRule$3({
+const rule$5 = createRule$4({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -5435,6 +5573,53 @@ const rule$4 = createRule$3({
     name: 'prefer-multi-arg-push',
 });
 
+const createRule$3 = ESLintUtils.RuleCreator((name) => name);
+function getModuleKeywordToken(sourceCode, node) {
+    const firstToken = sourceCode.getFirstToken(node);
+    if (!firstToken) {
+        return null;
+    }
+    if (firstToken.value === 'declare') {
+        return sourceCode.getTokenAfter(firstToken) ?? null;
+    }
+    return firstToken;
+}
+const rule$4 = createRule$3({
+    create(context) {
+        const { sourceCode } = context;
+        return {
+            TSModuleDeclaration(node) {
+                if (node.kind !== 'module' ||
+                    node.global ||
+                    node.id.type === AST_NODE_TYPES.Literal) {
+                    return;
+                }
+                const moduleKeywordToken = getModuleKeywordToken(sourceCode, node);
+                if (moduleKeywordToken?.value !== 'module') {
+                    return;
+                }
+                context.report({
+                    fix: (fixer) => fixer.replaceText(moduleKeywordToken, 'namespace'),
+                    messageId: 'useNamespaceKeyword',
+                    node: moduleKeywordToken,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Prefer `namespace Foo {}` over the older `module Foo {}` syntax for TypeScript namespace declarations.',
+        },
+        fixable: 'code',
+        messages: {
+            useNamespaceKeyword: 'Use `namespace` instead of `module` for TypeScript namespace declarations.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'prefer-namespace-keyword',
+});
+
 /**
  * prefer-untracked-incidental-signal-reads
  *
@@ -5492,17 +5677,6 @@ function unwrapUsageExpression(node) {
     }
     return current;
 }
-function isNodeInside(node, ancestor) {
-    for (let current = node; current; current = current.parent) {
-        if (current === ancestor) {
-            return true;
-        }
-    }
-    return false;
-}
-function isNodeInsideAny(node, ancestors) {
-    return ancestors.some((ancestor) => isNodeInside(node, ancestor));
-}
 function isStatementPositionCall(node) {
     const usage = unwrapUsageExpression(node);
     if (usage.parent?.type === AST_NODE_TYPES.ExpressionStatement) {
@@ -5555,11 +5729,7 @@ function isAliasDeclarationIdentifier(node) {
         node.parent.id === node);
 }
 function aliasHasExternalUsage(alias, consumers, scope, checker, esTreeNodeToTSNodeMap) {
-    const tsNode = esTreeNodeToTSNodeMap.get(alias);
-    if (!tsNode) {
-        return false;
-    }
-    const symbol = checker.getSymbolAtLocation(tsNode);
+    const symbol = getSymbolAtNode(alias, checker, esTreeNodeToTSNodeMap);
     if (!symbol) {
         return false;
     }
@@ -5571,10 +5741,7 @@ function aliasHasExternalUsage(alias, consumers, scope, checker, esTreeNodeToTSN
             isNodeInsideAny(node, consumers)) {
             return;
         }
-        const referenceTsNode = esTreeNodeToTSNodeMap.get(node);
-        const referenceSymbol = referenceTsNode
-            ? checker.getSymbolAtLocation(referenceTsNode)
-            : null;
+        const referenceSymbol = getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap);
         if (referenceSymbol !== symbol) {
             return;
         }
@@ -5601,11 +5768,7 @@ function resolveSignalReadAlias(expression, context, seen = new Set()) {
     if (unwrapped.type !== AST_NODE_TYPES.Identifier) {
         return null;
     }
-    const tsNode = context.esTreeNodeToTSNodeMap.get(unwrapped);
-    if (!tsNode) {
-        return null;
-    }
-    const symbol = context.checker.getSymbolAtLocation(tsNode);
+    const symbol = getSymbolAtNode(unwrapped, context.checker, context.esTreeNodeToTSNodeMap);
     if (!symbol) {
         return null;
     }
@@ -5693,12 +5856,9 @@ function collectSuspiciousReads(scope, checker, esTreeNodeToTSNodeMap, tsNodeToE
 }
 const rule$3 = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const tsNodeToESTreeNodeMap = parserServices.tsNodeToESTreeNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
+        const estreeNodeMap = tsNodeToESTreeNodeMap;
         function buildFix(read) {
             const untrackedAlias = findUntrackedAlias(program);
             const alreadyHasUntracked = untrackedAlias !== null;
@@ -5714,13 +5874,13 @@ const rule$3 = createUntrackedRule({
         return {
             CallExpression(node) {
                 for (const scope of getReactiveScopes(node, program)) {
-                    const suspicious = collectSuspiciousReads(scope, checker, esTreeNodeToTSNodeMap, tsNodeToESTreeNodeMap, program);
-                    const { reads: trackedReads } = collectSignalUsages(scope.callback, checker, esTreeNodeToTSNodeMap, program);
+                    const suspicious = collectSuspiciousReads(scope, checker, signalNodeMap, estreeNodeMap, program);
+                    const { reads: trackedReads } = collectSignalUsages(scope.callback, checker, signalNodeMap, program);
                     const suspiciousReads = new Set(suspicious.map(({ read }) => read));
                     for (const { aliases, consumers, read } of suspicious) {
                         const hasTrackedDependency = consumers.some((consumer) => trackedReads.some((trackedRead) => !suspiciousReads.has(trackedRead) &&
                             !isNodeInside(trackedRead, consumer)));
-                        const hasExternalAliasUsage = aliases.some((alias) => aliasHasExternalUsage(alias, consumers, scope, checker, esTreeNodeToTSNodeMap));
+                        const hasExternalAliasUsage = aliases.some((alias) => aliasHasExternalUsage(alias, consumers, scope, checker, signalNodeMap));
                         if (!hasTrackedDependency || hasExternalAliasUsage) {
                             continue;
                         }
@@ -5752,7 +5912,7 @@ const rule$3 = createUntrackedRule({
 
 function getReturnedExpression(node) {
     if (node.body.type !== AST_NODE_TYPES.BlockStatement) {
-        return unwrapExpression(node.body);
+        return node.body;
     }
     if (node.body.body.length !== 1) {
         return null;
@@ -5761,17 +5921,16 @@ function getReturnedExpression(node) {
     if (statement?.type !== AST_NODE_TYPES.ReturnStatement || !statement.argument) {
         return null;
     }
-    return unwrapExpression(statement.argument);
+    return statement.argument;
 }
+
 function getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap) {
-    const [arg] = node.arguments;
-    if (!arg ||
-        arg.type === AST_NODE_TYPES.SpreadElement ||
-        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+    const callback = getReactiveCallbackArgument(node);
+    if (!callback) {
         return null;
     }
-    const body = getReturnedExpression(arg);
+    const returnedExpression = getReturnedExpression(callback);
+    const body = returnedExpression ? unwrapExpression(returnedExpression) : null;
     if (body?.type !== AST_NODE_TYPES.CallExpression ||
         !isSignalReadCall(body, checker, esTreeNodeToTSNodeMap)) {
         return null;
@@ -5785,17 +5944,14 @@ function getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap) {
 }
 const rule$2 = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
         return {
             CallExpression(node) {
                 if (!isAngularUntrackedCall(node, program)) {
                     return;
                 }
-                const getter = getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap);
+                const getter = getWrappedSignalGetter(node, checker, signalNodeMap);
                 if (!getter) {
                     return;
                 }
@@ -5822,13 +5978,6 @@ const rule$2 = createUntrackedRule({
     name: 'prefer-untracked-signal-getter',
 });
 
-function getImportedName(spec) {
-    if (spec.imported.type === AST_NODE_TYPES.Identifier) {
-        return spec.imported.name;
-    }
-    return spec.imported.value;
-}
-
 function isImportsArrayProperty(property) {
     const isProperty = property?.type === AST_NODE_TYPES.Property;
     const hasIdentifierKey = property?.key.type === AST_NODE_TYPES.Identifier &&
@@ -5836,6 +5985,13 @@ function isImportsArrayProperty(property) {
     return isProperty && hasIdentifierKey && isArray(property.value);
 }
 
+function getImportedName(spec) {
+    if (spec.imported.type === AST_NODE_TYPES.Identifier) {
+        return spec.imported.name;
+    }
+    return spec.imported.value;
+}
+
 const MESSAGE_ID = 'replaceTuiImport';
 const DEFAULT_DECORATORS = ['Component', 'Directive', 'NgModule', 'Pipe'];
 const DEFAULT_EXCEPTIONS = [
@@ -6246,27 +6402,31 @@ const plugin = {
         'class-property-naming': classPropertyNaming,
         'decorator-key-sort': config$3,
         'flat-exports': flatExports,
-        'host-attributes-sort': rule$j,
+        'host-attributes-sort': rule$n,
         'html-logical-properties': config$2,
-        'injection-token-description': rule$i,
-        'no-deep-imports': rule$h,
+        'injection-token-description': rule$m,
+        'no-commonjs-import-patterns': rule$l,
+        'no-deep-imports': rule$k,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
-        'no-fully-untracked-effect': rule$g,
+        'no-fully-untracked-effect': rule$j,
         'no-href-with-router-link': config$1,
-        'no-implicit-public': rule$f,
-        'no-legacy-peer-deps': rule$e,
-        'no-playwright-empty-fill': rule$d,
+        'no-implicit-public': rule$i,
+        'no-import-assertions': rule$h,
+        'no-infinite-loop': rule$g,
+        'no-legacy-peer-deps': rule$f,
+        'no-playwright-empty-fill': rule$e,
         'no-project-as-in-ng-template': config,
-        'no-redundant-type-annotation': rule$c,
-        'no-side-effects-in-computed': rule$b,
-        'no-signal-reads-after-await-in-reactive-context': rule$a,
-        'no-string-literal-concat': rule$9,
-        'no-untracked-outside-reactive-context': rule$8,
-        'no-useless-untracked': rule$7,
-        'object-single-line': rule$6,
-        'prefer-combined-if-control-flow': rule$5,
+        'no-redundant-type-annotation': rule$d,
+        'no-side-effects-in-computed': rule$c,
+        'no-signal-reads-after-await-in-reactive-context': rule$b,
+        'no-string-literal-concat': rule$a,
+        'no-untracked-outside-reactive-context': rule$9,
+        'no-useless-untracked': rule$8,
+        'object-single-line': rule$7,
+        'prefer-combined-if-control-flow': rule$6,
         'prefer-deep-imports': preferDeepImports,
-        'prefer-multi-arg-push': rule$4,
+        'prefer-multi-arg-push': rule$5,
+        'prefer-namespace-keyword': rule$4,
         'prefer-untracked-incidental-signal-reads': rule$3,
         'prefer-untracked-signal-getter': rule$2,
         'short-tui-imports': rule$1,