eslint-plugin-svelte 3.12.2 → 3.12.4

package/README.md

@@ -85,6 +85,9 @@ export default [
         // By doing so, some rules in eslint-plugin-svelte will automatically read the configuration and adjust their behavior accordingly.
         // While certain Svelte settings may be statically loaded from svelte.config.js even if you don’t specify it,
         // explicitly specifying it ensures better compatibility and functionality.
+        //
+        // If non-serializable properties are included, running ESLint with the --cache flag will fail.
+        // In that case, please remove the non-serializable properties. (e.g. `svelteConfig: { ...svelteConfig, kit: { ...svelteConfig.kit, typescript: undefined }}`)
         svelteConfig
       }
     }
@@ -143,6 +146,9 @@ export default ts.config(
         // By doing so, some rules in eslint-plugin-svelte will automatically read the configuration and adjust their behavior accordingly.
         // While certain Svelte settings may be statically loaded from svelte.config.js even if you don’t specify it,
         // explicitly specifying it ensures better compatibility and functionality.
+        //
+        // If non-serializable properties are included, running ESLint with the --cache flag will fail.
+        // In that case, please remove the non-serializable properties. (e.g. `svelteConfig: { ...svelteConfig, kit: { ...svelteConfig.kit, typescript: undefined }}`)
         svelteConfig
       }
     }

package/lib/main.d.ts

@@ -14,7 +14,7 @@ export declare const configs: {
 export declare const rules: Record<string, Rule.RuleModule>;
 export declare const meta: {
     name: "eslint-plugin-svelte";
-    version: "3.12.2";
+    version: "3.12.4";
 };
 export declare const processors: {
     '.svelte': typeof processor;

package/lib/meta.d.ts

@@ -1,2 +1,2 @@
 export declare const name: "eslint-plugin-svelte";
-export declare const version: "3.12.2";
+export declare const version: "3.12.4";

package/lib/meta.js

@@ -2,4 +2,4 @@
 // This file has been automatically generated,
 // in order to update its content execute "pnpm run update"
 export const name = 'eslint-plugin-svelte';
-export const version = '3.12.2';
+export const version = '3.12.4';

package/lib/rules/no-dynamic-slot-name.js

@@ -1,5 +1,5 @@
 import { createRule } from '../utils/index.js';
-import { findVariable, getAttributeValueQuoteAndRange, getStringIfConstant } from '../utils/ast-utils.js';
+import { FindVariableContext, getAttributeValueQuoteAndRange, getStringIfConstant } from '../utils/ast-utils.js';
 export default createRule('no-dynamic-slot-name', {
     meta: {
         docs: {
@@ -56,16 +56,15 @@ export default createRule('no-dynamic-slot-name', {
          * Get static text from given expression
          */
         function getStaticText(node) {
-            const expr = findRootExpression(node);
+            const expr = findRootExpression(new FindVariableContext(context), node);
             return getStringIfConstant(expr);
         }
         /** Find data expression */
-        function findRootExpression(node, already = new Set()) {
-            if (node.type !== 'Identifier' || already.has(node)) {
+        function findRootExpression(ctx, node) {
+            if (node.type !== 'Identifier') {
                 return node;
             }
-            already.add(node);
-            const variable = findVariable(context, node);
+            const variable = ctx.findVariable(node);
             if (!variable || variable.defs.length !== 1) {
                 return node;
             }
@@ -73,7 +72,7 @@ export default createRule('no-dynamic-slot-name', {
             if (def.type === 'Variable') {
                 if (def.parent.kind === 'const' && def.node.init) {
                     const init = def.node.init;
-                    return findRootExpression(init, already);
+                    return findRootExpression(ctx, init);
                 }
             }
             return node;

package/lib/rules/no-immutable-reactive-statements.js

@@ -1,5 +1,5 @@
 import { createRule } from '../utils/index.js';
-import { findVariable, iterateIdentifiers } from '../utils/ast-utils.js';
+import { FindVariableContext, iterateIdentifiers } from '../utils/ast-utils.js';
 export default createRule('no-immutable-reactive-statements', {
     meta: {
         docs: {
@@ -81,7 +81,7 @@ export default createRule('no-immutable-reactive-statements', {
                             return true;
                         }
                     }
-                    return hasWrite(variable);
+                    return hasWrite(new FindVariableContext(context), variable);
                 }
                 return false;
             });
@@ -89,7 +89,7 @@ export default createRule('no-immutable-reactive-statements', {
             return isMutableDefine;
         }
         /** Checks whether the given variable has a write or reactive store reference or not. */
-        function hasWrite(variable) {
+        function hasWrite(ctx, variable) {
             const defIds = variable.defs.map((def) => def.name);
             for (const reference of variable.references) {
                 if (reference.isWrite() &&
@@ -97,14 +97,14 @@ export default createRule('no-immutable-reactive-statements', {
                         reference.identifier.range[1] <= defId.range[1])) {
                     return true;
                 }
-                if (hasWriteMember(reference.identifier)) {
+                if (hasWriteMember(ctx, reference.identifier)) {
                     return true;
                 }
             }
             return false;
         }
         /** Checks whether the given expression has writing to a member or not. */
-        function hasWriteMember(expr) {
+        function hasWriteMember(ctx, expr) {
             if (expr.type === 'JSXIdentifier')
                 return false;
             const parent = expr.parent;
@@ -118,21 +118,23 @@ export default createRule('no-immutable-reactive-statements', {
                 return parent.operator === 'delete' && parent.argument === expr;
             }
             if (parent.type === 'MemberExpression') {
-                return parent.object === expr && hasWriteMember(parent);
+                return parent.object === expr && hasWriteMember(ctx, parent);
             }
             if (parent.type === 'SvelteDirective') {
                 return parent.kind === 'Binding' && parent.expression === expr;
             }
             if (parent.type === 'SvelteEachBlock') {
-                return (parent.context !== null && parent.expression === expr && hasWriteReference(parent.context));
+                return (parent.context !== null &&
+                    parent.expression === expr &&
+                    hasWriteReference(ctx, parent.context));
             }
             return false;
         }
         /** Checks whether the given pattern has writing or not. */
-        function hasWriteReference(pattern) {
+        function hasWriteReference(ctx, pattern) {
             for (const id of iterateIdentifiers(pattern)) {
-                const variable = findVariable(context, id);
-                if (variable && hasWrite(variable))
+                const variable = ctx.findVariable(id);
+                if (variable && hasWrite(ctx, variable))
                     return true;
             }
             return false;

package/lib/rules/no-navigation-without-resolve.js

@@ -1,5 +1,6 @@
 import { createRule } from '../utils/index.js';
 import { ReferenceTracker } from '@eslint-community/eslint-utils';
+import { FindVariableContext } from '../utils/ast-utils.js';
 import { findVariable } from '../utils/ast-utils.js';
 export default createRule('no-navigation-without-resolve', {
     meta: {
@@ -74,12 +75,12 @@ export default createRule('no-navigation-without-resolve', {
                     return;
                 }
                 if ((node.value[0].type === 'SvelteLiteral' &&
-                    !expressionIsAbsolute(node.value[0]) &&
-                    !expressionIsFragment(node.value[0])) ||
+                    !expressionIsAbsolute(new FindVariableContext(context), node.value[0]) &&
+                    !expressionIsFragment(new FindVariableContext(context), node.value[0])) ||
                     (node.value[0].type === 'SvelteMustacheTag' &&
-                        !expressionIsAbsolute(node.value[0].expression) &&
-                        !expressionIsFragment(node.value[0].expression) &&
-                        !isResolveCall(context, node.value[0].expression, resolveReferences))) {
+                        !expressionIsAbsolute(new FindVariableContext(context), node.value[0].expression) &&
+                        !expressionIsFragment(new FindVariableContext(context), node.value[0].expression) &&
+                        !isResolveCall(new FindVariableContext(context), node.value[0].expression, resolveReferences))) {
                     context.report({ loc: node.value[0].loc, messageId: 'linkWithoutResolve' });
                 }
             }
@@ -149,7 +150,7 @@ function checkGotoCall(context, call, resolveReferences) {
         return;
     }
     const url = call.arguments[0];
-    if (!isResolveCall(context, url, resolveReferences)) {
+    if (!isResolveCall(new FindVariableContext(context), url, resolveReferences)) {
         context.report({ loc: url.loc, messageId: 'gotoWithoutResolve' });
     }
 }
@@ -158,12 +159,13 @@ function checkShallowNavigationCall(context, call, resolveReferences, messageId)
         return;
     }
     const url = call.arguments[0];
-    if (!expressionIsEmpty(url) && !isResolveCall(context, url, resolveReferences)) {
+    if (!expressionIsEmpty(url) &&
+        !isResolveCall(new FindVariableContext(context), url, resolveReferences)) {
         context.report({ loc: url.loc, messageId });
     }
 }
 // Helper functions
-function isResolveCall(context, node, resolveReferences) {
+function isResolveCall(ctx, node, resolveReferences) {
     if (node.type === 'CallExpression' &&
         ((node.callee.type === 'Identifier' && resolveReferences.has(node.callee)) ||
             (node.callee.type === 'MemberExpression' &&
@@ -171,17 +173,17 @@ function isResolveCall(context, node, resolveReferences) {
                 resolveReferences.has(node.callee.property)))) {
         return true;
     }
-    if (node.type === 'Identifier') {
-        const variable = findVariable(context, node);
-        if (variable !== null &&
-            variable.identifiers.length > 0 &&
-            variable.identifiers[0].parent.type === 'VariableDeclarator' &&
-            variable.identifiers[0].parent.init !== null &&
-            isResolveCall(context, variable.identifiers[0].parent.init, resolveReferences)) {
-            return true;
-        }
+    if (node.type !== 'Identifier') {
+        return false;
+    }
+    const variable = ctx.findVariable(node);
+    if (variable === null ||
+        variable.identifiers.length === 0 ||
+        variable.identifiers[0].parent.type !== 'VariableDeclarator' ||
+        variable.identifiers[0].parent.init === null) {
+        return false;
     }
-    return false;
+    return isResolveCall(ctx, variable.identifiers[0].parent.init, resolveReferences);
 }
 function expressionIsEmpty(url) {
     return ((url.type === 'Literal' && url.value === '') ||
@@ -190,50 +192,74 @@ function expressionIsEmpty(url) {
             url.quasis.length === 1 &&
             url.quasis[0].value.raw === ''));
 }
-function expressionIsAbsolute(url) {
+function expressionIsAbsolute(ctx, url) {
     switch (url.type) {
         case 'BinaryExpression':
-            return binaryExpressionIsAbsolute(url);
+            return binaryExpressionIsAbsolute(ctx, url);
+        case 'Identifier':
+            return identifierIsAbsolute(ctx, url);
         case 'Literal':
             return typeof url.value === 'string' && urlValueIsAbsolute(url.value);
         case 'SvelteLiteral':
             return urlValueIsAbsolute(url.value);
         case 'TemplateLiteral':
-            return templateLiteralIsAbsolute(url);
+            return templateLiteralIsAbsolute(ctx, url);
         default:
             return false;
     }
 }
-function binaryExpressionIsAbsolute(url) {
-    return ((url.left.type !== 'PrivateIdentifier' && expressionIsAbsolute(url.left)) ||
-        expressionIsAbsolute(url.right));
+function binaryExpressionIsAbsolute(ctx, url) {
+    return ((url.left.type !== 'PrivateIdentifier' && expressionIsAbsolute(ctx, url.left)) ||
+        expressionIsAbsolute(ctx, url.right));
+}
+function identifierIsAbsolute(ctx, url) {
+    const variable = ctx.findVariable(url);
+    if (variable === null ||
+        variable.identifiers.length === 0 ||
+        variable.identifiers[0].parent.type !== 'VariableDeclarator' ||
+        variable.identifiers[0].parent.init === null) {
+        return false;
+    }
+    return expressionIsAbsolute(ctx, variable.identifiers[0].parent.init);
 }
-function templateLiteralIsAbsolute(url) {
-    return (url.expressions.some(expressionIsAbsolute) ||
+function templateLiteralIsAbsolute(ctx, url) {
+    return (url.expressions.some((expression) => expressionIsAbsolute(ctx, expression)) ||
         url.quasis.some((quasi) => urlValueIsAbsolute(quasi.value.raw)));
 }
 function urlValueIsAbsolute(url) {
     return /^[+a-z]*:/i.test(url);
 }
-function expressionIsFragment(url) {
+function expressionIsFragment(ctx, url) {
     switch (url.type) {
         case 'BinaryExpression':
-            return binaryExpressionIsFragment(url);
+            return binaryExpressionIsFragment(ctx, url);
+        case 'Identifier':
+            return identifierIsFragment(ctx, url);
         case 'Literal':
             return typeof url.value === 'string' && urlValueIsFragment(url.value);
         case 'SvelteLiteral':
             return urlValueIsFragment(url.value);
         case 'TemplateLiteral':
-            return templateLiteralIsFragment(url);
+            return templateLiteralIsFragment(ctx, url);
         default:
             return false;
     }
 }
-function binaryExpressionIsFragment(url) {
-    return url.left.type !== 'PrivateIdentifier' && expressionIsFragment(url.left);
+function binaryExpressionIsFragment(ctx, url) {
+    return url.left.type !== 'PrivateIdentifier' && expressionIsFragment(ctx, url.left);
+}
+function identifierIsFragment(ctx, url) {
+    const variable = ctx.findVariable(url);
+    if (variable === null ||
+        variable.identifiers.length === 0 ||
+        variable.identifiers[0].parent.type !== 'VariableDeclarator' ||
+        variable.identifiers[0].parent.init === null) {
+        return false;
+    }
+    return expressionIsFragment(ctx, variable.identifiers[0].parent.init);
 }
-function templateLiteralIsFragment(url) {
-    return ((url.expressions.length >= 1 && expressionIsFragment(url.expressions[0])) ||
+function templateLiteralIsFragment(ctx, url) {
+    return ((url.expressions.length >= 1 && expressionIsFragment(ctx, url.expressions[0])) ||
         (url.quasis.length >= 1 && urlValueIsFragment(url.quasis[0].value.raw)));
 }
 function urlValueIsFragment(url) {

package/lib/rules/no-not-function-handler.js

@@ -1,6 +1,6 @@
 import { createRule } from '../utils/index.js';
-import { findVariable } from '../utils/ast-utils.js';
 import { EVENT_NAMES } from '../utils/events.js';
+import { FindVariableContext } from '../utils/ast-utils.js';
 const PHRASES = {
     ObjectExpression: 'object',
     ArrayExpression: 'array',
@@ -34,12 +34,11 @@ export default createRule('no-not-function-handler', {
     },
     create(context) {
         /** Find data expression */
-        function findRootExpression(node, already = new Set()) {
-            if (node.type !== 'Identifier' || already.has(node)) {
+        function findRootExpression(ctx, node) {
+            if (node.type !== 'Identifier') {
                 return node;
             }
-            already.add(node);
-            const variable = findVariable(context, node);
+            const variable = ctx.findVariable(node);
             if (!variable || variable.defs.length !== 1) {
                 return node;
             }
@@ -47,7 +46,7 @@ export default createRule('no-not-function-handler', {
             if (def.type === 'Variable') {
                 if (def.parent.kind === 'const' && def.node.init) {
                     const init = def.node.init;
-                    return findRootExpression(init, already);
+                    return findRootExpression(ctx, init);
                 }
             }
             return node;
@@ -57,7 +56,7 @@ export default createRule('no-not-function-handler', {
             if (!node) {
                 return;
             }
-            const expression = findRootExpression(node);
+            const expression = findRootExpression(new FindVariableContext(context), node);
             if (expression.type !== 'ObjectExpression' &&
                 expression.type !== 'ArrayExpression' &&
                 expression.type !== 'ClassExpression' &&

package/lib/rules/no-top-level-browser-globals.js

@@ -331,12 +331,23 @@ export default createRule('no-top-level-browser-globals', {
                 const end = pp.range[1];
                 return (n) => start <= n.range[0] && n.range[1] <= end;
             }
-            if (!guardInfo.not &&
-                parent.type === 'LogicalExpression' &&
-                parent.operator === '&&' &&
-                parent.left === guardInfo.node) {
-                const block = parent.right;
-                return (n) => block.range[0] <= n.range[0] && n.range[1] <= block.range[1];
+            if (parent.type === 'LogicalExpression') {
+                if (!guardInfo.not && parent.operator === '&&') {
+                    const parentChecker = getGuardChecker({ not: guardInfo.not, node: parent });
+                    if (parent.left === guardInfo.node) {
+                        const block = parent.right;
+                        return (n) => {
+                            if (parentChecker?.(n)) {
+                                return true;
+                            }
+                            return block.range[0] <= n.range[0] && n.range[1] <= block.range[1];
+                        };
+                    }
+                    return parentChecker;
+                }
+                if (guardInfo.not && parent.operator === '||') {
+                    return getGuardChecker({ not: guardInfo.not, node: parent });
+                }
             }
             return null;
         }

package/lib/rules/no-unused-props.js

@@ -2,6 +2,7 @@ import { createRule } from '../utils/index.js';
 import { getTypeScriptTools, isAnyType } from '../utils/ts-utils/index.js';
 import { findVariable } from '../utils/ast-utils.js';
 import { toRegExp } from '../utils/regexp.js';
+import { normalize } from 'path';
 let isRemovedWarningShown = false;
 export default createRule('no-unused-props', {
     meta: {
@@ -100,7 +101,8 @@ export default createRule('no-unused-props', {
             const declarations = symbol.getDeclarations();
             if (!declarations || declarations.length === 0)
                 return false;
-            return declarations.every((decl) => decl.getSourceFile().fileName === fileName);
+            // TypeScript declaration file name is normalized to support Windows style paths
+            return declarations.every((decl) => normalize(decl.getSourceFile().fileName) === fileName);
         }
         /**
          * Extracts property paths from member expressions.

package/lib/rules/valid-style-parse.js

@@ -1,4 +1,5 @@
 import { createRule } from '../utils/index.js';
+import path from 'path';
 export default createRule('valid-style-parse', {
     meta: {
         docs: {
@@ -15,14 +16,19 @@ export default createRule('valid-style-parse', {
         if (!sourceCode.parserServices.isSvelte) {
             return {};
         }
-        const cwd = `${context.cwd ?? process.cwd()}/`;
+        const cwd = `${context.cwd ?? process.cwd()}${path.sep}`;
         return {
             SvelteStyleElement(node) {
                 const styleContext = sourceCode.parserServices.getStyleContext();
                 if (styleContext.status === 'parse-error') {
+                    // This will replace backslashes to forward slashes only
+                    // 	if Node.js reports Windows style path separators
+                    let message = styleContext.error.message.replace(cwd, '');
+                    if (path.sep === '\\')
+                        message = message.replace(/\\/g, '/');
                     context.report({
                         loc: node.loc,
-                        message: `Error parsing style element. Error message: "${styleContext.error.message.replace(cwd, '')}"`
+                        message: `Error parsing style element. Error message: "${message}"`
                     });
                 }
                 if (styleContext.status === 'unknown-lang') {

package/lib/utils/ast-utils.d.ts

@@ -62,6 +62,17 @@ export declare function getLangValue(node: SvAST.SvelteScriptElement | SvAST.Sve
  * Find the variable of a given name.
  */
 export declare function findVariable(context: RuleContext, node: TSESTree.Identifier): Variable | null;
+/**
+ * Context for safely finding variables, avoiding infinite recursion.
+ * This should be used when the caller function may be called recursively, instead of `findVariable()`.
+ *
+ * Create an instance of this class at the top of the call stack where you want to start searching for identifiers,
+ * and then use it within the recursion.
+ */
+export declare class FindVariableContext {
+    readonly findVariable: (node: TSESTree.Identifier) => Variable | null;
+    constructor(context: RuleContext);
+}
 /**
  * Iterate the identifiers of a given pattern node.
  */

package/lib/utils/ast-utils.js

@@ -172,6 +172,25 @@ export function findVariable(context, node) {
     // Remove the $ and search for the variable again, as it may be a store access variable.
     return eslintUtils.findVariable(initialScope, node.name.slice(1));
 }
+/**
+ * Context for safely finding variables, avoiding infinite recursion.
+ * This should be used when the caller function may be called recursively, instead of `findVariable()`.
+ *
+ * Create an instance of this class at the top of the call stack where you want to start searching for identifiers,
+ * and then use it within the recursion.
+ */
+export class FindVariableContext {
+    constructor(context) {
+        const visited = new Set();
+        this.findVariable = (node) => {
+            if (visited.has(node)) {
+                return null;
+            }
+            visited.add(node);
+            return findVariable(context, node);
+        };
+    }
+}
 /**
  * Iterate the identifiers of a given pattern node.
  */

package/lib/utils/expression-affixes.js

@@ -1,6 +1,15 @@
-import { findVariable } from './ast-utils.js';
-// Variable prefix extraction
+import { FindVariableContext } from './ast-utils.js';
 export function extractExpressionPrefixVariable(context, expression) {
+    return extractExpressionPrefixVariableInternal(new FindVariableContext(context), expression);
+}
+export function extractExpressionPrefixLiteral(context, expression) {
+    return extractExpressionPrefixLiteralInternal(new FindVariableContext(context), expression);
+}
+export function extractExpressionSuffixLiteral(context, expression) {
+    return extractExpressionSuffixLiteralInternal(new FindVariableContext(context), expression);
+}
+// Variable prefix extraction
+function extractExpressionPrefixVariableInternal(context, expression) {
     switch (expression.type) {
         case 'BinaryExpression':
             return extractBinaryExpressionPrefixVariable(context, expression);
@@ -16,18 +25,19 @@ export function extractExpressionPrefixVariable(context, expression) {
 }
 function extractBinaryExpressionPrefixVariable(context, expression) {
     return expression.left.type !== 'PrivateIdentifier'
-        ? extractExpressionPrefixVariable(context, expression.left)
+        ? extractExpressionPrefixVariableInternal(context, expression.left)
         : null;
 }
 function extractVariablePrefixVariable(context, expression) {
-    const variable = findVariable(context, expression);
+    const variable = context.findVariable(expression);
     if (variable === null ||
         variable.identifiers.length !== 1 ||
         variable.identifiers[0].parent.type !== 'VariableDeclarator' ||
         variable.identifiers[0].parent.init === null) {
         return expression;
     }
-    return (extractExpressionPrefixVariable(context, variable.identifiers[0].parent.init) ?? expression);
+    return (extractExpressionPrefixVariableInternal(context, variable.identifiers[0].parent.init) ??
+        expression);
 }
 function extractMemberExpressionPrefixVariable(expression) {
     return expression.property.type === 'Identifier' ? expression.property : null;
@@ -40,14 +50,14 @@ function extractTemplateLiteralPrefixVariable(context, expression) {
             continue;
         }
         if (part.type !== 'TemplateElement') {
-            return extractExpressionPrefixVariable(context, part);
+            return extractExpressionPrefixVariableInternal(context, part);
         }
         return null;
     }
     return null;
 }
 // Literal prefix extraction
-export function extractExpressionPrefixLiteral(context, expression) {
+function extractExpressionPrefixLiteralInternal(context, expression) {
     switch (expression.type) {
         case 'BinaryExpression':
             return extractBinaryExpressionPrefixLiteral(context, expression);
@@ -65,18 +75,18 @@ export function extractExpressionPrefixLiteral(context, expression) {
 }
 function extractBinaryExpressionPrefixLiteral(context, expression) {
     return expression.left.type !== 'PrivateIdentifier'
-        ? extractExpressionPrefixLiteral(context, expression.left)
+        ? extractExpressionPrefixLiteralInternal(context, expression.left)
         : null;
 }
 function extractVariablePrefixLiteral(context, expression) {
-    const variable = findVariable(context, expression);
+    const variable = context.findVariable(expression);
     if (variable === null ||
         variable.identifiers.length !== 1 ||
         variable.identifiers[0].parent.type !== 'VariableDeclarator' ||
         variable.identifiers[0].parent.init === null) {
         return null;
     }
-    return extractExpressionPrefixLiteral(context, variable.identifiers[0].parent.init);
+    return extractExpressionPrefixLiteralInternal(context, variable.identifiers[0].parent.init);
 }
 function extractTemplateLiteralPrefixLiteral(context, expression) {
     const literalParts = [...expression.expressions, ...expression.quasis].sort((a, b) => a.range[0] < b.range[0] ? -1 : 1);
@@ -88,12 +98,12 @@ function extractTemplateLiteralPrefixLiteral(context, expression) {
             }
             return part.value.raw;
         }
-        return extractExpressionPrefixLiteral(context, part);
+        return extractExpressionPrefixLiteralInternal(context, part);
     }
     return null;
 }
 // Literal suffix extraction
-export function extractExpressionSuffixLiteral(context, expression) {
+function extractExpressionSuffixLiteralInternal(context, expression) {
     switch (expression.type) {
         case 'BinaryExpression':
             return extractBinaryExpressionSuffixLiteral(context, expression);
@@ -110,17 +120,17 @@ export function extractExpressionSuffixLiteral(context, expression) {
     }
 }
 function extractBinaryExpressionSuffixLiteral(context, expression) {
-    return extractExpressionSuffixLiteral(context, expression.right);
+    return extractExpressionSuffixLiteralInternal(context, expression.right);
 }
 function extractVariableSuffixLiteral(context, expression) {
-    const variable = findVariable(context, expression);
+    const variable = context.findVariable(expression);
     if (variable === null ||
         variable.identifiers.length !== 1 ||
         variable.identifiers[0].parent.type !== 'VariableDeclarator' ||
         variable.identifiers[0].parent.init === null) {
         return null;
     }
-    return extractExpressionSuffixLiteral(context, variable.identifiers[0].parent.init);
+    return extractExpressionSuffixLiteralInternal(context, variable.identifiers[0].parent.init);
 }
 function extractTemplateLiteralSuffixLiteral(context, expression) {
     const literalParts = [...expression.expressions, ...expression.quasis].sort((a, b) => a.range[0] < b.range[0] ? -1 : 1);
@@ -132,7 +142,7 @@ function extractTemplateLiteralSuffixLiteral(context, expression) {
             }
             return part.value.raw;
         }
-        return extractExpressionSuffixLiteral(context, part);
+        return extractExpressionSuffixLiteralInternal(context, part);
     }
     return null;
 }

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "eslint-plugin-svelte",
-  "version": "3.12.2",
+  "version": "3.12.4",
   "description": "ESLint plugin for Svelte using AST",
-  "repository": "git+https://github.com/sveltejs/eslint-plugin-svelte.git",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sveltejs/eslint-plugin-svelte.git",
+    "directory": "packages/eslint-plugin-svelte"
+  },
   "homepage": "https://sveltejs.github.io/eslint-plugin-svelte",
   "author": "Yosuke Ota (https://github.com/ota-meshi)",
   "funding": "https://github.com/sponsors/ota-meshi",
@@ -58,6 +62,8 @@
     "@types/postcss-safe-parser": "^5.0.4",
     "@types/semver": "^7.7.0",
     "@types/stylus": "^0.48.43",
+    "@typescript-eslint/scope-manager": "^8.43.0",
+    "@typescript-eslint/types": "^8.43.0",
     "acorn": "^8.15.0",
     "assert": "^2.1.0",
     "esbuild": "^0.25.9",
@@ -65,6 +71,7 @@
     "eslint-typegen": "^2.3.0",
     "eslint-visitor-keys": "^4.2.1",
     "espree": "^10.4.0",
+    "jiti": "^2.5.1",
     "less": "^4.4.1",
     "mocha": "~11.7.2",
     "postcss-nested": "^7.0.2",