@taiga-ui/eslint-plugin-experience-next 0.523.0 → 0.525.0

package/index.esm.js

@@ -1496,6 +1496,9 @@ var recommended = defineConfig([
                 'String.prototype.at',
                 'Touch',
                 'TouchEvent',
+                'MIDIMessageEvent',
+                'Notification',
+                'Permissions',
                 'document.fullscreenElement',
             ],
         },
@@ -14543,6 +14546,645 @@ Object.defineProperty(NoInfer, "__esModule", { value: true });
 	exports.TSUtils = __importStar(tsUtils); 
 } (dist$4));
 
+function isFunctionExpressionLike(node) {
+    return (node?.type === dist$4.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node?.type === dist$4.AST_NODE_TYPES.FunctionExpression);
+}
+function isFunctionLike(node) {
+    return (node.type === dist$4.AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === dist$4.AST_NODE_TYPES.FunctionDeclaration ||
+        node.type === dist$4.AST_NODE_TYPES.FunctionExpression);
+}
+function getOrderedChildren(node) {
+    if (isFunctionLike(node)) {
+        const children = [
+            ...node.params,
+            node.body,
+        ];
+        return children.filter((child) => child != null);
+    }
+    if (node.type === dist$4.AST_NODE_TYPES.BlockStatement ||
+        node.type === dist$4.AST_NODE_TYPES.Program) {
+        return node.body;
+    }
+    if (node.type === dist$4.AST_NODE_TYPES.IfStatement) {
+        return node.alternate
+            ? [node.test, node.consequent, node.alternate]
+            : [node.test, node.consequent];
+    }
+    if (node.type === dist$4.AST_NODE_TYPES.ConditionalExpression) {
+        return [node.test, node.consequent, node.alternate];
+    }
+    if (node.type === dist$4.AST_NODE_TYPES.WhileStatement) {
+        return [node.test, node.body];
+    }
+    if (node.type === dist$4.AST_NODE_TYPES.DoWhileStatement) {
+        return [node.body, node.test];
+    }
+    if (node.type === dist$4.AST_NODE_TYPES.ForStatement) {
+        const children = [
+            node.init && 'type' in node.init ? node.init : null,
+            node.test,
+            node.update,
+            node.body,
+        ];
+        return children.filter((child) => child != null);
+    }
+    if (node.type === dist$4.AST_NODE_TYPES.ForInStatement ||
+        node.type === dist$4.AST_NODE_TYPES.ForOfStatement) {
+        return [node.left, node.right, node.body];
+    }
+    const children = [];
+    for (const key of Object.keys(node)) {
+        if (key === 'parent') {
+            continue;
+        }
+        const child = node[key];
+        if (Array.isArray(child)) {
+            for (const item of child) {
+                if (item && typeof item === 'object' && 'type' in item) {
+                    children.push(item);
+                }
+            }
+        }
+        else if (child && typeof child === 'object' && 'type' in child) {
+            children.push(child);
+        }
+    }
+    return children;
+}
+/**
+ * Walks the synchronous portion of a reactive scope.
+ *
+ * - Stops descending into nested function boundaries, since they run in their
+ *   own call context and should not be treated as reads/writes of the current
+ *   reactive scope.
+ * - Traverses the argument of `await`, because it is evaluated synchronously,
+ *   then stops visiting subsequent sibling nodes in the current execution path.
+ */
+function walkSynchronousAst(root, visitor) {
+    traverse(root, true);
+    function traverse(node, isRoot = false) {
+        if (visitor(node) === false || (!isRoot && isFunctionLike(node))) {
+            return false;
+        }
+        if (node.type === dist$4.AST_NODE_TYPES.AwaitExpression) {
+            return traverse(node.argument, false) || true;
+        }
+        for (const child of getOrderedChildren(node)) {
+            if (traverse(child, false)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+/**
+ * Walks nodes that run after an async boundary inside a reactive callback.
+ *
+ * The traversal is intentionally conservative:
+ * - it never descends into nested function boundaries
+ * - it propagates async state through straight-line code
+ * - it does not propagate branch-local `await` from optional control-flow
+ *   bodies into later siblings, which avoids noisy false positives
+ */
+function walkAfterAsyncBoundaryAst(root, visitor) {
+    traverse(root, true, false);
+    function traverse(node, isRoot = false, afterBoundary = false) {
+        if (afterBoundary) {
+            visitor(node);
+        }
+        if (!isRoot && isFunctionLike(node)) {
+            return false;
+        }
+        if (node.type === dist$4.AST_NODE_TYPES.AwaitExpression) {
+            traverse(node.argument, false, afterBoundary);
+            return true;
+        }
+        if (node.type === dist$4.AST_NODE_TYPES.BlockStatement ||
+            node.type === dist$4.AST_NODE_TYPES.Program) {
+            let crossed = afterBoundary;
+            for (const child of node.body) {
+                const childCrossed = traverse(child, false, crossed);
+                crossed = crossed || childCrossed;
+            }
+            return crossed && !afterBoundary;
+        }
+        if (node.type === dist$4.AST_NODE_TYPES.IfStatement) {
+            const crossedInTest = traverse(node.test, false, afterBoundary);
+            const branchAfterBoundary = afterBoundary || crossedInTest;
+            traverse(node.consequent, false, branchAfterBoundary);
+            if (node.alternate) {
+                traverse(node.alternate, false, branchAfterBoundary);
+            }
+            return crossedInTest && !afterBoundary;
+        }
+        let crossed = afterBoundary;
+        for (const child of getOrderedChildren(node)) {
+            const childCrossed = traverse(child, false, crossed);
+            crossed = crossed || childCrossed;
+        }
+        return crossed && !afterBoundary;
+    }
+}
+/**
+ * Shallow AST walker. Visits `root` and every descendant, skipping the
+ * synthetic `parent` back-pointer to avoid cycles.
+ *
+ * If the visitor returns `false` for a node, that node's children are NOT
+ * visited (prune / stop-descend). Any other return value (including `void`)
+ * continues the walk.
+ */
+function walkAst(root, visitor) {
+    if (visitor(root) === false) {
+        return;
+    }
+    for (const key of Object.keys(root)) {
+        if (key === 'parent') {
+            continue;
+        }
+        const child = root[key];
+        if (Array.isArray(child)) {
+            for (const item of child) {
+                if (item && typeof item === 'object' && 'type' in item) {
+                    walkAst(item, visitor);
+                }
+            }
+        }
+        else if (child && typeof child === 'object' && 'type' in child) {
+            walkAst(child, visitor);
+        }
+    }
+}
+
+function isAstNode(value) {
+    if (!value || typeof value !== 'object' || !('type' in value)) {
+        return false;
+    }
+    const { type } = value;
+    return typeof type === 'string';
+}
+function getParentNode(node) {
+    const maybeNode = node;
+    if (!maybeNode || typeof maybeNode !== 'object' || !('parent' in maybeNode)) {
+        return null;
+    }
+    const { parent } = maybeNode;
+    return isAstNode(parent) ? parent : null;
+}
+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 === dist$4.AST_NODE_TYPES.ClassDeclaration ||
+        node.type === dist$4.AST_NODE_TYPES.ClassExpression);
+}
+function isClassMember(node) {
+    return (node.type === dist$4.AST_NODE_TYPES.MethodDefinition ||
+        node.type === dist$4.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 === dist$4.AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
+}
+
+function getParenthesizedInner(node) {
+    const maybeNode = node;
+    return maybeNode.type === 'ParenthesizedExpression'
+        ? (maybeNode.expression ?? null)
+        : null;
+}
+function unwrapParenthesized(node) {
+    let current = node;
+    let inner = getParenthesizedInner(current);
+    while (inner) {
+        current = inner;
+        inner = getParenthesizedInner(current);
+    }
+    return current;
+}
+
+/**
+ * Strips expression wrapper nodes that do not affect the underlying expression:
+ * parentheses, `as` casts, `satisfies`, non-null assertions (`!`), type
+ * assertions (`<T>expr`), and optional-chain wrappers. Iterates until no more
+ * wrappers are found.
+ */
+function unwrapExpression(expression) {
+    let current = expression;
+    let didUnwrap = true;
+    while (didUnwrap) {
+        didUnwrap = false;
+        const parenthesized = getParenthesizedExpression(current);
+        if (parenthesized) {
+            current = parenthesized;
+            didUnwrap = true;
+            continue;
+        }
+        switch (current.type) {
+            case dist$4.AST_NODE_TYPES.ChainExpression:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+            case dist$4.AST_NODE_TYPES.TSAsExpression:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+            case dist$4.AST_NODE_TYPES.TSNonNullExpression:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+            case dist$4.AST_NODE_TYPES.TSSatisfiesExpression:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+            case dist$4.AST_NODE_TYPES.TSTypeAssertion:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+        }
+    }
+    return current;
+}
+function hasNonNullAssertionParent(node) {
+    let current = node;
+    let parent = getParentNode(current);
+    while (parent) {
+        if (parent.type === dist$4.AST_NODE_TYPES.TSNonNullExpression &&
+            parent.expression === current) {
+            return true;
+        }
+        if (getParenthesizedInner(parent) !== current) {
+            return false;
+        }
+        current = parent;
+        parent = getParentNode(current);
+    }
+    return false;
+}
+function isExpressionLike(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'type' in value &&
+        typeof value.type === 'string');
+}
+function getParenthesizedExpression(expression) {
+    const maybeExpression = expression;
+    return maybeExpression.type === 'ParenthesizedExpression' &&
+        isExpressionLike(maybeExpression.expression)
+        ? maybeExpression.expression
+        : null;
+}
+
+const EQUALITY_OPERATORS = new Set(['!=', '!==', '==', '===']);
+function getChainExpressionRoot(node) {
+    const parent = getParentNode(node);
+    return parent?.type === dist$4.AST_NODE_TYPES.ChainExpression ? parent : node;
+}
+function isLogicalFallbackLeftOperand(node) {
+    const expression = getChainExpressionRoot(node);
+    const parent = getParentNode(expression);
+    return (parent?.type === dist$4.AST_NODE_TYPES.LogicalExpression &&
+        (parent.operator === '??' || parent.operator === '||') &&
+        parent.left === expression);
+}
+function getContainingIfStatementForTestExpression(node) {
+    let current = getChainExpressionRoot(node);
+    let parent = getParentNode(current);
+    while (parent?.type === dist$4.AST_NODE_TYPES.LogicalExpression) {
+        current = parent;
+        parent = getParentNode(parent);
+    }
+    if (parent?.type === dist$4.AST_NODE_TYPES.UnaryExpression && parent.operator === '!') {
+        current = parent;
+        parent = getParentNode(parent);
+    }
+    return parent?.type === dist$4.AST_NODE_TYPES.IfStatement && parent.test === current
+        ? parent
+        : null;
+}
+function isConditionTestExpression(node) {
+    let current = getChainExpressionRoot(node);
+    let parent = getParentNode(current);
+    if (!parent) {
+        return false;
+    }
+    while (parent?.type === dist$4.AST_NODE_TYPES.LogicalExpression) {
+        current = parent;
+        parent = getParentNode(parent);
+    }
+    if (!parent) {
+        return false;
+    }
+    if (parent.type === dist$4.AST_NODE_TYPES.UnaryExpression && parent.operator === '!') {
+        current = parent;
+        parent = getParentNode(parent);
+    }
+    return parent
+        ? (parent.type === dist$4.AST_NODE_TYPES.IfStatement && parent.test === current) ||
+            (parent.type === dist$4.AST_NODE_TYPES.ConditionalExpression &&
+                parent.test === current) ||
+            (parent.type === dist$4.AST_NODE_TYPES.WhileStatement &&
+                parent.test === current) ||
+            (parent.type === dist$4.AST_NODE_TYPES.DoWhileStatement &&
+                parent.test === current) ||
+            (parent.type === dist$4.AST_NODE_TYPES.ForStatement && parent.test === current)
+        : false;
+}
+function isEqualityComparisonOperand(node) {
+    const expression = getChainExpressionRoot(node);
+    const parent = getParentNode(expression);
+    return (parent?.type === dist$4.AST_NODE_TYPES.BinaryExpression &&
+        EQUALITY_OPERATORS.has(parent.operator));
+}
+
+function getSafeBracketIndexText(sourceCode, node) {
+    if (!node.computed || node.property.type !== dist$4.AST_NODE_TYPES.Literal) {
+        return null;
+    }
+    const { value } = node.property;
+    if (typeof value !== 'number') {
+        return null;
+    }
+    const hasSameAtIndexSemantics = Number.isInteger(value) && value >= 0;
+    return hasSameAtIndexSemantics ? sourceCode.getText(node.property) : null;
+}
+function getMemberAccessStart(sourceCode, node) {
+    const tokenBeforeProperty = sourceCode.getTokenBefore(node.property);
+    if (!tokenBeforeProperty) {
+        return null;
+    }
+    if (!node.computed) {
+        return tokenBeforeProperty.range[0];
+    }
+    if (tokenBeforeProperty.value !== '[') {
+        return null;
+    }
+    const tokenBeforeBracket = sourceCode.getTokenBefore(tokenBeforeProperty);
+    const hasOptionalBracketAccess = node.optional && tokenBeforeBracket?.value === '?.';
+    return hasOptionalBracketAccess
+        ? tokenBeforeBracket.range[0]
+        : tokenBeforeProperty.range[0];
+}
+function isSameIndexedAccess(sourceCode, left, right) {
+    const leftIndexText = getSafeBracketIndexText(sourceCode, left);
+    const rightIndexText = getSafeBracketIndexText(sourceCode, right);
+    return (leftIndexText !== null &&
+        leftIndexText === rightIndexText &&
+        sourceCode.getText(left.object) === sourceCode.getText(right.object));
+}
+
+function unwrapMutationTarget(node) {
+    let current = node;
+    while (current.type === dist$4.AST_NODE_TYPES.TSAsExpression ||
+        current.type === dist$4.AST_NODE_TYPES.TSNonNullExpression ||
+        current.type === dist$4.AST_NODE_TYPES.TSTypeAssertion) {
+        current = current.expression;
+    }
+    return current;
+}
+function collectMutationTargets(node) {
+    const current = unwrapMutationTarget(node);
+    switch (current.type) {
+        case dist$4.AST_NODE_TYPES.ArrayPattern:
+            return current.elements.flatMap((element) => element ? collectMutationTargets(element) : []);
+        case dist$4.AST_NODE_TYPES.AssignmentPattern:
+            return collectMutationTargets(current.left);
+        case dist$4.AST_NODE_TYPES.Identifier:
+            return [current];
+        case dist$4.AST_NODE_TYPES.MemberExpression:
+            return [current];
+        case dist$4.AST_NODE_TYPES.ObjectPattern:
+            return current.properties.flatMap((property) => property.type === dist$4.AST_NODE_TYPES.RestElement
+                ? collectMutationTargets(property.argument)
+                : collectMutationTargets(property.value));
+        case dist$4.AST_NODE_TYPES.RestElement:
+            return collectMutationTargets(current.argument);
+        default:
+            return [];
+    }
+}
+function getMutationExpressionTarget(node) {
+    if (node.type === dist$4.AST_NODE_TYPES.AssignmentExpression ||
+        node.type === dist$4.AST_NODE_TYPES.UpdateExpression) {
+        return node.type === dist$4.AST_NODE_TYPES.AssignmentExpression
+            ? node.left
+            : node.argument;
+    }
+    return node.type === dist$4.AST_NODE_TYPES.UnaryExpression && node.operator === 'delete'
+        ? node.argument
+        : null;
+}
+function isMutationTarget(node) {
+    const { parent } = node;
+    if (!parent) {
+        return false;
+    }
+    const isForLoopTarget = parent.type === dist$4.AST_NODE_TYPES.ForInStatement ||
+        parent.type === dist$4.AST_NODE_TYPES.ForOfStatement;
+    return isForLoopTarget
+        ? parent.left === node
+        : getMutationExpressionTarget(parent) === node;
+}
+
+function hasSameIndexedAssignmentTarget(sourceCode, root, target) {
+    let found = false;
+    walkAst(root, (node) => {
+        const shouldStopWalking = found || (node !== root && isFunctionExpressionLike(node));
+        if (shouldStopWalking) {
+            return false;
+        }
+        const isGuardedAssignmentTarget = node.type === dist$4.AST_NODE_TYPES.MemberExpression &&
+            isMutationTarget(node) &&
+            isSameIndexedAccess(sourceCode, node, target);
+        if (!isGuardedAssignmentTarget) {
+            return;
+        }
+        found = true;
+        return false;
+    });
+    return found;
+}
+function isIndexedAccessGuardingSameIndexAssignment(sourceCode, node) {
+    const ifStatement = getContainingIfStatementForTestExpression(node);
+    return ifStatement
+        ? hasSameIndexedAssignmentTarget(sourceCode, ifStatement.consequent, node)
+        : false;
+}
+
+function isStringLiteral$1(node) {
+    return node?.type === dist$4.AST_NODE_TYPES.Literal && typeof node.value === 'string';
+}
+function isStaticTemplateLiteral(node) {
+    return (node?.type === dist$4.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1);
+}
+function getStaticStringValue(node) {
+    if (isStringLiteral$1(node)) {
+        return node.value;
+    }
+    return isStaticTemplateLiteral(node)
+        ? (node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? '')
+        : null;
+}
+function isEmptyStaticString(node) {
+    return getStaticStringValue(node) === '';
+}
+
+function getStaticPropertyName(key) {
+    if (key.type === dist$4.AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    return key.type === dist$4.AST_NODE_TYPES.Literal &&
+        (typeof key.value === 'string' || typeof key.value === 'number')
+        ? String(key.value)
+        : getStaticStringValue(key);
+}
+function getObjectPropertyName(node) {
+    return node.computed ? null : getStaticPropertyName(node.key);
+}
+function getMemberExpressionPropertyName(node) {
+    if (!node.computed && node.property.type === dist$4.AST_NODE_TYPES.Identifier) {
+        return node.property.name;
+    }
+    return node.computed ? getStaticStringValue(node.property) : null;
+}
+function getClassMemberName(member) {
+    return member.key.type === dist$4.AST_NODE_TYPES.PrivateIdentifier
+        ? null
+        : getStaticPropertyName(member.key);
+}
+
+function isSingleLineNode(node) {
+    return node.loc.start.line === node.loc.end.line;
+}
+function hasCommentLikeText(text) {
+    return text.includes('//') || text.includes('/*');
+}
+function hasBlankLine(text) {
+    let lineBreaks = 0;
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (char === '\n') {
+            lineBreaks++;
+        }
+        else if (char === '\r') {
+            lineBreaks++;
+            if (text[index + 1] === '\n') {
+                index++;
+            }
+        }
+        if (lineBreaks > 1) {
+            return true;
+        }
+    }
+    return false;
+}
+function getLineBreak(text) {
+    if (text.includes('\r\n')) {
+        return '\r\n';
+    }
+    return text.includes('\r') ? '\r' : '\n';
+}
+function getLeadingIndentation(text) {
+    let index = 0;
+    while (index < text.length && (text[index] === ' ' || text[index] === '\t')) {
+        index++;
+    }
+    return text.slice(0, index);
+}
+function getLineStartOffset(text, offset) {
+    return text.lastIndexOf('\n', offset - 1) + 1;
+}
+function getIndentAtOffset(text, offset) {
+    const lineStart = getLineStartOffset(text, offset);
+    const indent = text.slice(lineStart, offset);
+    return indent.trim() === '' ? indent : '';
+}
+function getSpacingReplacement(sourceCode, betweenText, nextLine, blankLineCount) {
+    const indentation = getLeadingIndentation(sourceCode.lines[nextLine - 1] ?? '');
+    return `${getLineBreak(betweenText).repeat(blankLineCount + 1)}${indentation}`;
+}
+
+const RULE_DOCS_BASE_URL = 'https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs';
+const ruleCreator = dist$4.ESLintUtils.RuleCreator((name) => `${RULE_DOCS_BASE_URL}/${name}.md`);
+function createRule(options) {
+    if ('rule' in options) {
+        const { name, rule } = options;
+        const meta = rule.meta ?? {};
+        const docs = meta.docs ?? {};
+        return ruleCreator({
+            create: (context) => rule.create(context),
+            meta: {
+                ...meta,
+                docs: {
+                    ...docs,
+                    description: typeof docs.description === 'string' ? docs.description : name,
+                },
+            },
+            name,
+        });
+    }
+    return ruleCreator(options);
+}
+
+function getResolvedVariable(sourceCode, node) {
+    const scope = sourceCode.getScope(node);
+    const reference = scope.references.find((item) => item.identifier === node);
+    return reference?.resolved ?? null;
+}
+function hasVariableInScope(sourceCode, node, name) {
+    let scope = sourceCode.getScope(node);
+    while (scope) {
+        if (scope.variables.some((variable) => variable.name === name)) {
+            return true;
+        }
+        scope = scope.upper;
+    }
+    return false;
+}
+
 function commonjsRequire(path) {
 	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
 }
@@ -215187,331 +215829,34 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 var typescriptExports = typescript.exports;
 var ts = /*@__PURE__*/getDefaultExportFromCjs(typescriptExports);
 
-function isFunctionLike(node) {
-    return (node.type === dist$4.AST_NODE_TYPES.ArrowFunctionExpression ||
-        node.type === dist$4.AST_NODE_TYPES.FunctionDeclaration ||
-        node.type === dist$4.AST_NODE_TYPES.FunctionExpression);
-}
-function getOrderedChildren(node) {
-    if (isFunctionLike(node)) {
-        const children = [
-            ...node.params,
-            node.body,
-        ];
-        return children.filter((child) => child != null);
-    }
-    if (node.type === dist$4.AST_NODE_TYPES.BlockStatement ||
-        node.type === dist$4.AST_NODE_TYPES.Program) {
-        return node.body;
-    }
-    if (node.type === dist$4.AST_NODE_TYPES.IfStatement) {
-        return node.alternate
-            ? [node.test, node.consequent, node.alternate]
-            : [node.test, node.consequent];
-    }
-    if (node.type === dist$4.AST_NODE_TYPES.ConditionalExpression) {
-        return [node.test, node.consequent, node.alternate];
-    }
-    if (node.type === dist$4.AST_NODE_TYPES.WhileStatement) {
-        return [node.test, node.body];
-    }
-    if (node.type === dist$4.AST_NODE_TYPES.DoWhileStatement) {
-        return [node.body, node.test];
-    }
-    if (node.type === dist$4.AST_NODE_TYPES.ForStatement) {
-        const children = [
-            node.init && 'type' in node.init ? node.init : null,
-            node.test,
-            node.update,
-            node.body,
-        ];
-        return children.filter((child) => child != null);
-    }
-    if (node.type === dist$4.AST_NODE_TYPES.ForInStatement ||
-        node.type === dist$4.AST_NODE_TYPES.ForOfStatement) {
-        return [node.left, node.right, node.body];
-    }
-    const children = [];
-    for (const key of Object.keys(node)) {
-        if (key === 'parent') {
-            continue;
-        }
-        const child = node[key];
-        if (Array.isArray(child)) {
-            for (const item of child) {
-                if (item && typeof item === 'object' && 'type' in item) {
-                    children.push(item);
-                }
-            }
-        }
-        else if (child && typeof child === 'object' && 'type' in child) {
-            children.push(child);
-        }
-    }
-    return children;
-}
-/**
- * Walks the synchronous portion of a reactive scope.
- *
- * - Stops descending into nested function boundaries, since they run in their
- *   own call context and should not be treated as reads/writes of the current
- *   reactive scope.
- * - Traverses the argument of `await`, because it is evaluated synchronously,
- *   then stops visiting subsequent sibling nodes in the current execution path.
- */
-function walkSynchronousAst(root, visitor) {
-    traverse(root, true);
-    function traverse(node, isRoot = false) {
-        if (visitor(node) === false || (!isRoot && isFunctionLike(node))) {
-            return false;
-        }
-        if (node.type === dist$4.AST_NODE_TYPES.AwaitExpression) {
-            return traverse(node.argument, false) || true;
-        }
-        for (const child of getOrderedChildren(node)) {
-            if (traverse(child, false)) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
-/**
- * Walks nodes that run after an async boundary inside a reactive callback.
- *
- * The traversal is intentionally conservative:
- * - it never descends into nested function boundaries
- * - it propagates async state through straight-line code
- * - it does not propagate branch-local `await` from optional control-flow
- *   bodies into later siblings, which avoids noisy false positives
- */
-function walkAfterAsyncBoundaryAst(root, visitor) {
-    traverse(root, true, false);
-    function traverse(node, isRoot = false, afterBoundary = false) {
-        if (afterBoundary) {
-            visitor(node);
-        }
-        if (!isRoot && isFunctionLike(node)) {
-            return false;
-        }
-        if (node.type === dist$4.AST_NODE_TYPES.AwaitExpression) {
-            traverse(node.argument, false, afterBoundary);
-            return true;
-        }
-        if (node.type === dist$4.AST_NODE_TYPES.BlockStatement ||
-            node.type === dist$4.AST_NODE_TYPES.Program) {
-            let crossed = afterBoundary;
-            for (const child of node.body) {
-                const childCrossed = traverse(child, false, crossed);
-                crossed = crossed || childCrossed;
-            }
-            return crossed && !afterBoundary;
-        }
-        if (node.type === dist$4.AST_NODE_TYPES.IfStatement) {
-            const crossedInTest = traverse(node.test, false, afterBoundary);
-            const branchAfterBoundary = afterBoundary || crossedInTest;
-            traverse(node.consequent, false, branchAfterBoundary);
-            if (node.alternate) {
-                traverse(node.alternate, false, branchAfterBoundary);
-            }
-            return crossedInTest && !afterBoundary;
-        }
-        let crossed = afterBoundary;
-        for (const child of getOrderedChildren(node)) {
-            const childCrossed = traverse(child, false, crossed);
-            crossed = crossed || childCrossed;
-        }
-        return crossed && !afterBoundary;
-    }
-}
-/**
- * Shallow AST walker. Visits `root` and every descendant, skipping the
- * synthetic `parent` back-pointer to avoid cycles.
- *
- * If the visitor returns `false` for a node, that node's children are NOT
- * visited (prune / stop-descend). Any other return value (including `void`)
- * continues the walk.
- */
-function walkAst(root, visitor) {
-    if (visitor(root) === false) {
-        return;
-    }
-    for (const key of Object.keys(root)) {
-        if (key === 'parent') {
-            continue;
-        }
-        const child = root[key];
-        if (Array.isArray(child)) {
-            for (const item of child) {
-                if (item && typeof item === 'object' && 'type' in item) {
-                    walkAst(item, visitor);
-                }
-            }
-        }
-        else if (child && typeof child === 'object' && 'type' in child) {
-            walkAst(child, visitor);
-        }
-    }
-}
-
-function getParenthesizedInner(node) {
-    const maybeNode = node;
-    return maybeNode.type === 'ParenthesizedExpression'
-        ? (maybeNode.expression ?? null)
-        : null;
-}
-function unwrapParenthesized(node) {
-    let current = node;
-    let inner = getParenthesizedInner(current);
-    while (inner) {
-        current = inner;
-        inner = getParenthesizedInner(current);
-    }
-    return current;
-}
-
-function isStringLiteral$1(node) {
-    return node?.type === dist$4.AST_NODE_TYPES.Literal && typeof node.value === 'string';
-}
-function isStaticTemplateLiteral(node) {
-    return (node?.type === dist$4.AST_NODE_TYPES.TemplateLiteral &&
-        node.expressions.length === 0 &&
-        node.quasis.length === 1);
-}
-function getStaticStringValue(node) {
-    if (isStringLiteral$1(node)) {
-        return node.value;
-    }
-    return isStaticTemplateLiteral(node)
-        ? (node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? '')
-        : null;
-}
-function isEmptyStaticString(node) {
-    return getStaticStringValue(node) === '';
-}
-
-function getStaticPropertyName(key) {
-    if (key.type === dist$4.AST_NODE_TYPES.Identifier) {
-        return key.name;
-    }
-    return key.type === dist$4.AST_NODE_TYPES.Literal &&
-        (typeof key.value === 'string' || typeof key.value === 'number')
-        ? String(key.value)
-        : getStaticStringValue(key);
-}
-function getObjectPropertyName(node) {
-    return node.computed ? null : getStaticPropertyName(node.key);
-}
-function getMemberExpressionPropertyName(node) {
-    if (!node.computed && node.property.type === dist$4.AST_NODE_TYPES.Identifier) {
-        return node.property.name;
-    }
-    return node.computed ? getStaticStringValue(node.property) : null;
-}
-function getClassMemberName(member) {
-    return member.key.type === dist$4.AST_NODE_TYPES.PrivateIdentifier
-        ? null
-        : getStaticPropertyName(member.key);
-}
-
-function isSingleLineNode(node) {
-    return node.loc.start.line === node.loc.end.line;
-}
-function hasCommentLikeText(text) {
-    return text.includes('//') || text.includes('/*');
-}
-function hasBlankLine(text) {
-    let lineBreaks = 0;
-    for (let index = 0; index < text.length; index++) {
-        const char = text[index];
-        if (char === '\n') {
-            lineBreaks++;
-        }
-        else if (char === '\r') {
-            lineBreaks++;
-            if (text[index + 1] === '\n') {
-                index++;
-            }
-        }
-        if (lineBreaks > 1) {
-            return true;
-        }
-    }
-    return false;
-}
-function getLineBreak(text) {
-    if (text.includes('\r\n')) {
-        return '\r\n';
-    }
-    return text.includes('\r') ? '\r' : '\n';
+const NULLISH_TYPE_FLAGS = typescriptExports.TypeFlags.Null | typescriptExports.TypeFlags.Undefined | typescriptExports.TypeFlags.Void;
+function isAnyOrUnknownType(type) {
+    return (type.flags & (typescriptExports.TypeFlags.Any | typescriptExports.TypeFlags.Unknown)) !== 0;
 }
-function getLeadingIndentation(text) {
-    let index = 0;
-    while (index < text.length && (text[index] === ' ' || text[index] === '\t')) {
-        index++;
-    }
-    return text.slice(0, index);
+function isInterfaceType(type) {
+    return 'getBaseTypes' in type && typeof type.getBaseTypes === 'function';
 }
-function getIndentAtOffset(text, offset) {
-    const lineStart = text.lastIndexOf('\n', offset - 1) + 1;
-    const indent = text.slice(lineStart, offset);
-    return indent.trim() === '' ? indent : '';
+function isNullishType(type) {
+    return (type.flags & NULLISH_TYPE_FLAGS) !== 0;
 }
-function getSpacingReplacement(sourceCode, betweenText, nextLine, blankLineCount) {
-    const indentation = getLeadingIndentation(sourceCode.lines[nextLine - 1] ?? '');
-    return `${getLineBreak(betweenText).repeat(blankLineCount + 1)}${indentation}`;
+function hasNullishType(type) {
+    return type.isUnion() ? type.types.some(hasNullishType) : isNullishType(type);
 }
-
-const RULE_DOCS_BASE_URL = 'https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs';
-const ruleCreator = dist$4.ESLintUtils.RuleCreator((name) => `${RULE_DOCS_BASE_URL}/${name}.md`);
-function createRule(options) {
-    if ('rule' in options) {
-        const { name, rule } = options;
-        const meta = rule.meta ?? {};
-        const docs = meta.docs ?? {};
-        return ruleCreator({
-            create: (context) => rule.create(context),
-            meta: {
-                ...meta,
-                docs: {
-                    ...docs,
-                    description: typeof docs.description === 'string' ? docs.description : name,
-                },
-            },
-            name,
-        });
+function isKnownTupleType(typeChecker, type, visitedTypes = new Set()) {
+    const shouldSkipReceiverType = isAnyOrUnknownType(type) || visitedTypes.has(type);
+    if (shouldSkipReceiverType) {
+        return false;
     }
-    return ruleCreator(options);
-}
-
-function getResolvedVariable(sourceCode, node) {
-    const scope = sourceCode.getScope(node);
-    const reference = scope.references.find((item) => item.identifier === node);
-    return reference?.resolved ?? null;
-}
-function hasVariableInScope(sourceCode, node, name) {
-    let scope = sourceCode.getScope(node);
-    while (scope) {
-        if (scope.variables.some((variable) => variable.name === name)) {
-            return true;
-        }
-        scope = scope.upper;
+    visitedTypes.add(type);
+    if (type.isUnion()) {
+        const definedTypes = type.types.filter((item) => !isNullishType(item));
+        return (definedTypes.length > 0 &&
+            definedTypes.every((item) => isKnownTupleType(typeChecker, item, visitedTypes)));
     }
-    return false;
-}
-
-function getTypeAwareRuleContext(context) {
-    const parserServices = dist$4.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,
-    };
+    return type.isIntersection()
+        ? type.types.some((item) => isKnownTupleType(typeChecker, item, visitedTypes))
+        : typeChecker.isTupleType(type) ||
+            typeChecker.isTupleType(typeChecker.getApparentType(type));
 }
 
 const BUILT_IN_AT_RECEIVER_NAMES = new Set([
@@ -215530,26 +215875,8 @@ const BUILT_IN_AT_RECEIVER_NAMES = new Set([
     'Uint8Array',
     'Uint8ClampedArray',
 ]);
-const SUPPORTED_STATEMENT_TYPES = new Set([
-    dist$4.AST_NODE_TYPES.ExpressionStatement,
-    dist$4.AST_NODE_TYPES.ReturnStatement,
-    dist$4.AST_NODE_TYPES.ThrowStatement,
-    dist$4.AST_NODE_TYPES.VariableDeclaration,
-]);
-const NULLISH_TYPE_FLAGS = typescriptExports.TypeFlags.Null | typescriptExports.TypeFlags.Undefined | typescriptExports.TypeFlags.Void;
-const FALLBACK_SCRIPT_TARGET = typescriptExports.ScriptTarget.ES2021;
-function supportsAt(target) {
-    return target >= typescriptExports.ScriptTarget.ES2022;
-}
-function isInterfaceType(type) {
-    return 'getBaseTypes' in type && typeof type.getBaseTypes === 'function';
-}
-function isNullishType(type) {
-    return (type.flags & NULLISH_TYPE_FLAGS) !== 0;
-}
-function hasKnownBuiltInAtReceiver(typeChecker, type, visitedTypes = new Set()) {
-    const hasNoReliableType = (type.flags & (typescriptExports.TypeFlags.Any | typescriptExports.TypeFlags.Unknown)) !== 0;
-    const shouldSkipReceiverType = hasNoReliableType || visitedTypes.has(type);
+function hasBuiltInAtReceiverType(typeChecker, type, visitedTypes = new Set()) {
+    const shouldSkipReceiverType = isAnyOrUnknownType(type) || visitedTypes.has(type);
     if (shouldSkipReceiverType) {
         return false;
     }
@@ -215557,10 +215884,10 @@ function hasKnownBuiltInAtReceiver(typeChecker, type, visitedTypes = new Set())
     if (type.isUnion()) {
         const definedTypes = type.types.filter((item) => !isNullishType(item));
         return (definedTypes.length > 0 &&
-            definedTypes.every((item) => hasKnownBuiltInAtReceiver(typeChecker, item, visitedTypes)));
+            definedTypes.every((item) => hasBuiltInAtReceiverType(typeChecker, item, visitedTypes)));
     }
     if (type.isIntersection()) {
-        return type.types.some((item) => hasKnownBuiltInAtReceiver(typeChecker, item, visitedTypes));
+        return type.types.some((item) => hasBuiltInAtReceiverType(typeChecker, item, visitedTypes));
     }
     const apparentType = typeChecker.getApparentType(type);
     if (typeChecker.isArrayType(apparentType) || typeChecker.isTupleType(apparentType)) {
@@ -215572,9 +215899,60 @@ function hasKnownBuiltInAtReceiver(typeChecker, type, visitedTypes = new Set())
         return true;
     }
     return isInterfaceType(apparentType)
-        ? (apparentType.getBaseTypes() ?? []).some((baseType) => hasKnownBuiltInAtReceiver(typeChecker, baseType, visitedTypes))
+        ? (apparentType.getBaseTypes() ?? []).some((baseType) => hasBuiltInAtReceiverType(typeChecker, baseType, visitedTypes))
         : false;
 }
+
+const FALLBACK_SCRIPT_TARGET = typescriptExports.ScriptTarget.ES2021;
+function normalizeLibName(name) {
+    return name
+        .toLowerCase()
+        .replace(/^lib\./, '')
+        .replace(/\.d\.ts$/, '');
+}
+function isFullEs2022OrLaterLib(name) {
+    if (name === 'esnext' || name === 'esnext.full') {
+        return true;
+    }
+    const match = /^es(?<year>\d{4})(?:\.full)?$/.exec(name);
+    const year = match?.groups?.['year'];
+    return year !== undefined && Number(year) >= 2022;
+}
+function hasBuiltInAtLib(libs) {
+    if (!libs) {
+        return true;
+    }
+    const normalizedLibs = libs.map(normalizeLibName);
+    const hasFullAtLib = normalizedLibs.some(isFullEs2022OrLaterLib);
+    const hasPartialAtLibs = normalizedLibs.includes('es2022.array') &&
+        normalizedLibs.includes('es2022.string');
+    return hasFullAtLib || hasPartialAtLibs;
+}
+function supportsBuiltInAt(compilerOptions) {
+    const target = compilerOptions.target ?? FALLBACK_SCRIPT_TARGET;
+    return target >= typescriptExports.ScriptTarget.ES2022 && hasBuiltInAtLib(compilerOptions.lib);
+}
+
+function getTypeAwareRuleContext(context) {
+    const parserServices = dist$4.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 SUPPORTED_STATEMENT_TYPES = new Set([
+    dist$4.AST_NODE_TYPES.ExpressionStatement,
+    dist$4.AST_NODE_TYPES.ReturnStatement,
+    dist$4.AST_NODE_TYPES.ThrowStatement,
+    dist$4.AST_NODE_TYPES.VariableDeclaration,
+]);
 function getAtCall(node) {
     const { parent } = node;
     const isSafeAtCall = parent.type === dist$4.AST_NODE_TYPES.CallExpression &&
@@ -215608,109 +215986,17 @@ function getAtIndex(sourceCode, call) {
         ? { text: sourceCode.getText(index), type: 'nonNegative' }
         : null;
 }
-function getSafeBracketIndexText(sourceCode, node) {
-    if (!node.computed || node.property.type !== dist$4.AST_NODE_TYPES.Literal) {
-        return null;
+function appendAtFallback(node, atCallText, indexedAccessTypeAlreadyIncludesUndefined) {
+    if (indexedAccessTypeAlreadyIncludesUndefined) {
+        return atCallText;
     }
-    const { value } = node.property;
-    if (typeof value !== 'number') {
-        return null;
-    }
-    const hasSameAtIndexSemantics = Number.isInteger(value) && value >= 0;
-    return hasSameAtIndexSemantics ? sourceCode.getText(node.property) : null;
-}
-function getNodeParent(node) {
-    const nodeWithParent = node;
-    return nodeWithParent.parent ?? null;
-}
-function getReplacementExpression(node) {
-    const parent = getNodeParent(node);
-    return parent?.type === dist$4.AST_NODE_TYPES.ChainExpression ? parent : node;
-}
-function isLogicalFallbackOperand(node) {
-    const expression = getReplacementExpression(node);
-    const parent = getNodeParent(expression);
-    return (parent?.type === dist$4.AST_NODE_TYPES.LogicalExpression &&
-        (parent.operator === '??' || parent.operator === '||') &&
-        parent.left === expression);
-}
-function isConditionExpression(node) {
-    let current = getReplacementExpression(node);
-    let parent = getNodeParent(current);
-    if (!parent) {
-        return false;
-    }
-    while (parent?.type === dist$4.AST_NODE_TYPES.LogicalExpression) {
-        current = parent;
-        parent = getNodeParent(parent);
-    }
-    if (!parent) {
-        return false;
-    }
-    if (parent.type === dist$4.AST_NODE_TYPES.UnaryExpression && parent.operator === '!') {
-        current = parent;
-        parent = getNodeParent(parent);
-    }
-    return parent
-        ? (parent.type === dist$4.AST_NODE_TYPES.IfStatement && parent.test === current) ||
-            (parent.type === dist$4.AST_NODE_TYPES.ConditionalExpression &&
-                parent.test === current) ||
-            (parent.type === dist$4.AST_NODE_TYPES.WhileStatement &&
-                parent.test === current) ||
-            (parent.type === dist$4.AST_NODE_TYPES.DoWhileStatement &&
-                parent.test === current) ||
-            (parent.type === dist$4.AST_NODE_TYPES.ForStatement && parent.test === current)
-        : false;
-}
-function appendAtFallback(node, atCallText) {
-    const canUseSurroundingFallback = isLogicalFallbackOperand(node) || isConditionExpression(node);
+    const canUseSurroundingFallback = isLogicalFallbackLeftOperand(node) ||
+        isConditionTestExpression(node) ||
+        isEqualityComparisonOperand(node);
     return node.optional || canUseSurroundingFallback || hasNonNullAssertionParent(node)
         ? atCallText
         : `${atCallText}!`;
 }
-function hasNonNullAssertionParent(node) {
-    let current = node;
-    let parent = getNodeParent(current);
-    while (parent) {
-        if (parent.type === dist$4.AST_NODE_TYPES.TSNonNullExpression &&
-            parent.expression === current) {
-            return true;
-        }
-        if (getParenthesizedInner(parent) !== current) {
-            return false;
-        }
-        current = parent;
-        parent = getNodeParent(current);
-    }
-    return false;
-}
-function isAssignmentTarget(node) {
-    const { parent } = node;
-    return ((parent.type === dist$4.AST_NODE_TYPES.AssignmentExpression && parent.left === node) ||
-        (parent.type === dist$4.AST_NODE_TYPES.UpdateExpression && parent.argument === node) ||
-        (parent.type === dist$4.AST_NODE_TYPES.UnaryExpression &&
-            parent.operator === 'delete' &&
-            parent.argument === node) ||
-        (parent.type === dist$4.AST_NODE_TYPES.ForInStatement && parent.left === node) ||
-        (parent.type === dist$4.AST_NODE_TYPES.ForOfStatement && parent.left === node));
-}
-function getMemberAccessStart(sourceCode, node) {
-    const tokenBeforeProperty = sourceCode.getTokenBefore(node.property);
-    if (!tokenBeforeProperty) {
-        return null;
-    }
-    if (!node.computed) {
-        return tokenBeforeProperty.range[0];
-    }
-    if (tokenBeforeProperty.value !== '[') {
-        return null;
-    }
-    const tokenBeforeBracket = sourceCode.getTokenBefore(tokenBeforeProperty);
-    const hasOptionalBracketAccess = node.optional && tokenBeforeBracket?.value === '?.';
-    return hasOptionalBracketAccess
-        ? tokenBeforeBracket.range[0]
-        : tokenBeforeProperty.range[0];
-}
 function getAtCallText(sourceCode, node, indexText, useOptionalAccess) {
     const accessStart = getMemberAccessStart(sourceCode, node);
     if (accessStart === null) {
@@ -215731,15 +216017,6 @@ function isRepeatableReceiver(node) {
             return false;
     }
 }
-function getLineIndent(text, start) {
-    const lineStart = getLineStart$1(text, start);
-    const linePrefix = text.slice(lineStart, start);
-    const indent = /^\s*/.exec(linePrefix);
-    return indent?.[0] ?? '';
-}
-function getLineStart$1(text, start) {
-    return text.lastIndexOf('\n', start - 1) + 1;
-}
 function capitalize(value) {
     return value.length > 0 ? `${value[0]?.toUpperCase()}${value.slice(1)}` : value;
 }
@@ -215827,7 +216104,7 @@ function isSupportedStatement(node) {
 function getSupportedStatement(node) {
     let current = node.parent;
     while (current) {
-        if (isFunctionExpressionBoundary(current)) {
+        if (isFunctionExpressionLike(current)) {
             return null;
         }
         const { parent } = current;
@@ -215859,7 +216136,7 @@ function isNonRepeatableLastAtCall(sourceCode, node) {
 function hasMultipleNonRepeatableLastAtCalls(sourceCode, root) {
     let count = 0;
     walkAst(root, (node) => {
-        if (node !== root && isFunctionExpressionBoundary(node)) {
+        if (node !== root && isFunctionExpressionLike(node)) {
             return false;
         }
         if (isNonRepeatableLastAtCall(sourceCode, node)) {
@@ -215869,17 +216146,13 @@ function hasMultipleNonRepeatableLastAtCalls(sourceCode, root) {
     });
     return count > 1;
 }
-function isFunctionExpressionBoundary(node) {
-    return (node.type === dist$4.AST_NODE_TYPES.ArrowFunctionExpression ||
-        node.type === dist$4.AST_NODE_TYPES.FunctionExpression);
-}
 function getClassPropertyWithoutFunctionBoundary(node) {
     let current = node.parent;
     while (current) {
         if (current.type === dist$4.AST_NODE_TYPES.PropertyDefinition) {
             return current;
         }
-        if (isFunctionExpressionBoundary(current)) {
+        if (isFunctionExpressionLike(current)) {
             return null;
         }
         current = current.parent;
@@ -215887,9 +216160,24 @@ function getClassPropertyWithoutFunctionBoundary(node) {
     return null;
 }
 function getClassPropertyPrefix(property) {
-    const modifiers = ['private', property.static ? 'static' : null, 'readonly'].filter((modifier) => Boolean(modifier));
+    if (property.key.type === dist$4.AST_NODE_TYPES.PrivateIdentifier) {
+        return property.static ? 'static ' : '';
+    }
+    const modifiers = [
+        property.accessibility,
+        property.static ? 'static' : null,
+        'readonly',
+    ].filter((modifier) => Boolean(modifier));
     return `${modifiers.join(' ')} `;
 }
+function getClassPropertyDeclarationName(property, name) {
+    return property.key.type === dist$4.AST_NODE_TYPES.PrivateIdentifier ? `#${name}` : name;
+}
+function getClassPropertyReceiver(property, name) {
+    return property.key.type === dist$4.AST_NODE_TYPES.PrivateIdentifier
+        ? `this.#${name}`
+        : `this.${name}`;
+}
 function getLastIndexFix(fixer, sourceCode, node, call) {
     if (node.optional) {
         return null;
@@ -215905,8 +216193,8 @@ function getLastIndexFix(fixer, sourceCode, node, call) {
             return null;
         }
         const temporaryName = getAvailableTemporaryName(sourceCode, call, preferredNames, null);
-        const indent = getLineIndent(sourceCode.text, statement.range[0]);
-        const lineStart = getLineStart$1(sourceCode.text, statement.range[0]);
+        const indent = getIndentAtOffset(sourceCode.text, statement.range[0]);
+        const lineStart = getLineStartOffset(sourceCode.text, statement.range[0]);
         const lineBreak = getLineBreak(sourceCode.text);
         return [
             fixer.insertTextBeforeRange([lineStart, lineStart], `${indent}const ${temporaryName} = ${objectText};${lineBreak}`),
@@ -215920,12 +216208,13 @@ function getLastIndexFix(fixer, sourceCode, node, call) {
             return null;
         }
         const propertyName = getAvailableTemporaryName(sourceCode, call, preferredNames, classBody);
-        const receiverText = `this.${propertyName}`;
-        const indent = getLineIndent(sourceCode.text, property.range[0]);
-        const lineStart = getLineStart$1(sourceCode.text, property.range[0]);
+        const declarationName = getClassPropertyDeclarationName(property, propertyName);
+        const receiverText = getClassPropertyReceiver(property, propertyName);
+        const indent = getIndentAtOffset(sourceCode.text, property.range[0]);
+        const lineStart = getLineStartOffset(sourceCode.text, property.range[0]);
         const lineBreak = getLineBreak(sourceCode.text);
         return [
-            fixer.insertTextBeforeRange([lineStart, lineStart], `${indent}${getClassPropertyPrefix(property)}${propertyName} = ${objectText};${lineBreak}${lineBreak}`),
+            fixer.insertTextBeforeRange([lineStart, lineStart], `${indent}${getClassPropertyPrefix(property)}${declarationName} = ${objectText};${lineBreak}${lineBreak}`),
             fixer.replaceText(call, `${receiverText}[${receiverText}.length - 1]`),
         ];
     }
@@ -215934,21 +216223,29 @@ function getLastIndexFix(fixer, sourceCode, node, call) {
 const rule$X = createRule({
     create(context) {
         const typeAwareContext = getTypeAwareRuleContext(context);
-        const scriptTarget = typeAwareContext.tsProgram.getCompilerOptions().target ??
-            FALLBACK_SCRIPT_TARGET;
-        const canUseAt = supportsAt(scriptTarget);
+        const compilerOptions = typeAwareContext.tsProgram.getCompilerOptions();
+        const canUseAt = supportsBuiltInAt(compilerOptions);
         const { checker: typeChecker, esTreeNodeToTSNodeMap } = typeAwareContext;
         const { sourceCode } = context;
         return {
             MemberExpression(node) {
                 if (canUseAt) {
                     const indexText = getSafeBracketIndexText(sourceCode, node);
-                    if (indexText === null || isAssignmentTarget(node)) {
+                    if (indexText === null || isMutationTarget(node)) {
                         return;
                     }
                     const tsObjectNode = esTreeNodeToTSNodeMap.get(node.object);
+                    const tsIndexedAccessNode = esTreeNodeToTSNodeMap.get(node);
                     const objectType = typeChecker.getTypeAtLocation(tsObjectNode);
-                    if (!hasKnownBuiltInAtReceiver(typeChecker, objectType)) {
+                    const indexedAccessType = typeChecker.getTypeAtLocation(tsIndexedAccessNode);
+                    const indexedAccessTypeAlreadyIncludesUndefined = compilerOptions.noUncheckedIndexedAccess === true &&
+                        hasNullishType(indexedAccessType);
+                    const shouldPreserveIndexedAccessNarrowing = indexedAccessTypeAlreadyIncludesUndefined &&
+                        isIndexedAccessGuardingSameIndexAssignment(sourceCode, node);
+                    const shouldSkipPreferAt = !hasBuiltInAtReceiverType(typeChecker, objectType) ||
+                        isKnownTupleType(typeChecker, objectType) ||
+                        shouldPreserveIndexedAccessNarrowing;
+                    if (shouldSkipPreferAt) {
                         return;
                     }
                     const useOptionalAccess = node.optional;
@@ -215957,7 +216254,7 @@ const rule$X = createRule({
                             const atCallText = getAtCallText(sourceCode, node, indexText, useOptionalAccess);
                             return atCallText === null
                                 ? null
-                                : fixer.replaceText(node, appendAtFallback(node, atCallText));
+                                : fixer.replaceText(node, appendAtFallback(node, atCallText, indexedAccessTypeAlreadyIncludesUndefined));
                         },
                         messageId: 'atCompatPreferAt',
                         node: node.property,
@@ -215969,7 +216266,7 @@ const rule$X = createRule({
                 }
                 const tsObjectNode = esTreeNodeToTSNodeMap.get(node.object);
                 const objectType = typeChecker.getTypeAtLocation(tsObjectNode);
-                if (!hasKnownBuiltInAtReceiver(typeChecker, objectType)) {
+                if (!hasBuiltInAtReceiverType(typeChecker, objectType)) {
                     return;
                 }
                 context.report({
@@ -250500,8 +250797,7 @@ const AFTER_RENDER_EFFECT_PHASES = new Map([
     ['write', 'afterRenderEffect().write'],
 ]);
 function isReactiveCallback(node) {
-    return (node?.type === dist$4.AST_NODE_TYPES.ArrowFunctionExpression ||
-        node?.type === dist$4.AST_NODE_TYPES.FunctionExpression);
+    return isFunctionExpressionLike(node);
 }
 function getReactiveCallbackArgument(node) {
     const [arg] = node.arguments;
@@ -250874,62 +251170,6 @@ const rule$H = createRule({
     rule: config$3,
 });
 
-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 === dist$4.AST_NODE_TYPES.ClassDeclaration ||
-        node.type === dist$4.AST_NODE_TYPES.ClassExpression);
-}
-function isClassMember(node) {
-    return (node.type === dist$4.AST_NODE_TYPES.MethodDefinition ||
-        node.type === dist$4.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 === dist$4.AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
-}
-
 const rule$G = createRule({
     create(context) {
         const checkImplicitPublic = (node) => {
@@ -252234,9 +252474,7 @@ const rule$w = createRule({
             // only explicit return type declaration (satisfying
             // @typescript-eslint/explicit-function-return-type via
             // allowTypedFunctionExpressions). Removing it would break that rule.
-            if ((value.type === dist$4.AST_NODE_TYPES.ArrowFunctionExpression ||
-                value.type === dist$4.AST_NODE_TYPES.FunctionExpression) &&
-                !value.returnType) {
+            if (isFunctionExpressionLike(value) && !value.returnType) {
                 return;
             }
             // If the annotation provides contextual typing that narrows an array
@@ -252247,7 +252485,7 @@ const rule$w = createRule({
                 const arrayExpressions = collectArrayExpressions(value);
                 for (const arrayExpression of arrayExpressions) {
                     const tsArrayNode = esTreeNodeToTSNodeMap.get(arrayExpression);
-                    if (typeChecker.isTupleType(typeChecker.getTypeAtLocation(tsArrayNode))) {
+                    if (isKnownTupleType(typeChecker, typeChecker.getTypeAtLocation(tsArrayNode))) {
                         return;
                     }
                 }
@@ -252311,13 +252549,7 @@ const rule$w = createRule({
 function isNullableCallType(call, checker, nodeMap) {
     try {
         const tsNode = nodeMap.get(call);
-        if (!tsNode) {
-            return false;
-        }
-        const type = checker.getTypeAtLocation(tsNode);
-        return type.flags & ts.TypeFlags.Union
-            ? type.types.some((t) => !!(t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)))
-            : false;
+        return tsNode ? hasNullishType(checker.getTypeAtLocation(tsNode)) : false;
     }
     catch {
         return false;
@@ -252372,40 +252604,22 @@ function findConciseArrowAncestor(node) {
 }
 function getArrowBodyIndent(arrowFn, sourceText) {
     const arrowStart = arrowFn.range[0];
-    const lineStart = sourceText.lastIndexOf('\n', arrowStart - 1) + 1;
+    const lineStart = getLineStartOffset(sourceText, arrowStart);
     const textBeforeArrow = sourceText.slice(lineStart, arrowStart);
     const outerIndent = /^(\s*)/.exec(textBeforeArrow)?.[1] ?? '';
     return { innerIndent: `${outerIndent}    `, outerIndent };
 }
 function getStatementIndent$1(statement, sourceText) {
-    const start = statement.range[0];
-    const lineStart = sourceText.lastIndexOf('\n', start - 1) + 1;
-    const before = sourceText.slice(lineStart, start);
-    return /^\s*$/.test(before) ? before : '';
-}
-function isAstNode(value) {
-    if (!value || typeof value !== 'object' || !('type' in value)) {
-        return false;
-    }
-    const { type } = value;
-    return typeof type === 'string';
-}
-function getParent(node) {
-    const maybeNode = node;
-    if (!maybeNode || typeof maybeNode !== 'object' || !('parent' in maybeNode)) {
-        return null;
-    }
-    const { parent } = maybeNode;
-    return isAstNode(parent) ? parent : null;
+    return getIndentAtOffset(sourceText, statement.range[0]);
 }
 function isOptionalMemberReceiver(call) {
     let current = call;
-    let parent = getParent(current);
+    let parent = getParentNode(current);
     while (parent?.type === dist$4.AST_NODE_TYPES.TSAsExpression ||
         parent?.type === dist$4.AST_NODE_TYPES.TSNonNullExpression ||
         parent?.type === dist$4.AST_NODE_TYPES.TSTypeAssertion) {
         current = parent;
-        parent = getParent(current);
+        parent = getParentNode(current);
     }
     return (parent?.type === dist$4.AST_NODE_TYPES.MemberExpression &&
         parent.object === current &&
@@ -252513,93 +252727,6 @@ const rule$v = createRule({
     name: 'no-repeated-signal-in-conditional',
 });
 
-/**
- * Strips expression wrapper nodes that do not affect the underlying expression:
- * parentheses, `as` casts, `satisfies`, non-null assertions (`!`), type
- * assertions (`<T>expr`), and optional-chain wrappers. Iterates until no more
- * wrappers are found.
- */
-function unwrapExpression(expression) {
-    let current = expression;
-    let didUnwrap = true;
-    while (didUnwrap) {
-        didUnwrap = false;
-        const parenthesized = getParenthesizedExpression(current);
-        if (parenthesized) {
-            current = parenthesized;
-            didUnwrap = true;
-            continue;
-        }
-        switch (current.type) {
-            case dist$4.AST_NODE_TYPES.ChainExpression:
-                current = current.expression;
-                didUnwrap = true;
-                break;
-            case dist$4.AST_NODE_TYPES.TSAsExpression:
-                current = current.expression;
-                didUnwrap = true;
-                break;
-            case dist$4.AST_NODE_TYPES.TSNonNullExpression:
-                current = current.expression;
-                didUnwrap = true;
-                break;
-            case dist$4.AST_NODE_TYPES.TSSatisfiesExpression:
-                current = current.expression;
-                didUnwrap = true;
-                break;
-            case dist$4.AST_NODE_TYPES.TSTypeAssertion:
-                current = current.expression;
-                didUnwrap = true;
-                break;
-        }
-    }
-    return current;
-}
-function isExpressionLike(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        'type' in value &&
-        typeof value.type === 'string');
-}
-function getParenthesizedExpression(expression) {
-    const maybeExpression = expression;
-    return maybeExpression.type === 'ParenthesizedExpression' &&
-        isExpressionLike(maybeExpression.expression)
-        ? maybeExpression.expression
-        : null;
-}
-
-function unwrapMutationTarget(node) {
-    let current = node;
-    while (current.type === dist$4.AST_NODE_TYPES.TSAsExpression ||
-        current.type === dist$4.AST_NODE_TYPES.TSNonNullExpression ||
-        current.type === dist$4.AST_NODE_TYPES.TSTypeAssertion) {
-        current = current.expression;
-    }
-    return current;
-}
-function collectMutationTargets(node) {
-    const current = unwrapMutationTarget(node);
-    switch (current.type) {
-        case dist$4.AST_NODE_TYPES.ArrayPattern:
-            return current.elements.flatMap((element) => element ? collectMutationTargets(element) : []);
-        case dist$4.AST_NODE_TYPES.AssignmentPattern:
-            return collectMutationTargets(current.left);
-        case dist$4.AST_NODE_TYPES.Identifier:
-            return [current];
-        case dist$4.AST_NODE_TYPES.MemberExpression:
-            return [current];
-        case dist$4.AST_NODE_TYPES.ObjectPattern:
-            return current.properties.flatMap((property) => property.type === dist$4.AST_NODE_TYPES.RestElement
-                ? collectMutationTargets(property.argument)
-                : collectMutationTargets(property.value));
-        case dist$4.AST_NODE_TYPES.RestElement:
-            return collectMutationTargets(current.argument);
-        default:
-            return [];
-    }
-}
-
 function getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap) {
     const tsNode = esTreeNodeToTSNodeMap.get(node);
     return tsNode ? (checker.getSymbolAtLocation(tsNode) ?? null) : null;
@@ -252787,19 +252914,9 @@ function functionHasObservableSideEffects(root, context, localScopes, visitedFun
                 return false;
             }
         }
-        if (node.type === dist$4.AST_NODE_TYPES.AssignmentExpression &&
-            hasObservableMutationTarget(node.left, context, localScopes)) {
-            hasSideEffect = true;
-            return false;
-        }
-        if (node.type === dist$4.AST_NODE_TYPES.UpdateExpression &&
-            hasObservableMutationTarget(node.argument, context, localScopes)) {
-            hasSideEffect = true;
-            return false;
-        }
-        if (node.type === dist$4.AST_NODE_TYPES.UnaryExpression &&
-            node.operator === 'delete' &&
-            hasObservableMutationTarget(node.argument, context, localScopes)) {
+        const mutationTarget = getMutationExpressionTarget(node);
+        if (mutationTarget &&
+            hasObservableMutationTarget(mutationTarget, context, localScopes)) {
             hasSideEffect = true;
             return false;
         }
@@ -252840,18 +252957,10 @@ function inspectComputedBody(root, context, localScopes, visitedFunctions, repor
                 return false;
             }
         }
-        if (node.type === dist$4.AST_NODE_TYPES.AssignmentExpression &&
-            hasObservableMutationTarget(node.left, context, localScopes)) {
-            reportSideEffect(node.left, context, report);
-        }
-        if (node.type === dist$4.AST_NODE_TYPES.UpdateExpression &&
-            hasObservableMutationTarget(node.argument, context, localScopes)) {
-            reportSideEffect(node.argument, context, report);
-        }
-        if (node.type === dist$4.AST_NODE_TYPES.UnaryExpression &&
-            node.operator === 'delete' &&
-            hasObservableMutationTarget(node.argument, context, localScopes)) {
-            reportSideEffect(node.argument, context, report);
+        const mutationTarget = getMutationExpressionTarget(node);
+        if (mutationTarget &&
+            hasObservableMutationTarget(mutationTarget, context, localScopes)) {
+            reportSideEffect(mutationTarget, context, report);
         }
         return;
     });