feat: docker compose maybe

node_modules/eslint-plugin-svelte/lib/utils/ast-utils.d.ts

@@ -0,0 +1,55 @@
+import type { ASTNode, RuleContext, SourceCode } from '../types';
+import type { TSESTree } from '@typescript-eslint/types';
+import type { Scope, Variable } from '@typescript-eslint/scope-manager';
+import type { AST as SvAST } from 'svelte-eslint-parser';
+export declare function equalTokens(left: ASTNode, right: ASTNode, sourceCode: SourceCode): boolean;
+export declare function getStringIfConstant(node: TSESTree.Expression | TSESTree.PrivateIdentifier): string | null;
+export declare function needParentheses(node: TSESTree.Expression, kind: 'not' | 'logical'): boolean;
+export declare function isHTMLElementLike(node: SvAST.SvelteElement | SvAST.SvelteScriptElement | SvAST.SvelteStyleElement): node is SvAST.SvelteHTMLElement | (SvAST.SvelteSpecialElement & {
+    name: SvAST.SvelteName & {
+        name: 'svelte:element';
+    };
+});
+export declare function findAttribute<N extends string>(node: SvAST.SvelteElement | SvAST.SvelteScriptElement | SvAST.SvelteStyleElement | SvAST.SvelteStartTag, name: N): (SvAST.SvelteAttribute & {
+    key: SvAST.SvelteAttribute['key'] & {
+        name: N;
+    };
+}) | null;
+export declare function findShorthandAttribute<N extends string>(node: SvAST.SvelteElement | SvAST.SvelteScriptElement | SvAST.SvelteStyleElement | SvAST.SvelteStartTag, name: N): (SvAST.SvelteShorthandAttribute & {
+    key: SvAST.SvelteShorthandAttribute['key'] & {
+        name: N;
+    };
+}) | null;
+export declare function findBindDirective<N extends string>(node: SvAST.SvelteElement | SvAST.SvelteScriptElement | SvAST.SvelteStyleElement | SvAST.SvelteStartTag, name: N): (SvAST.SvelteBindingDirective & {
+    key: SvAST.SvelteDirectiveKey & {
+        name: SvAST.SvelteDirectiveKey['name'] & {
+            name: N;
+        };
+    };
+}) | null;
+export declare function getStaticAttributeValue(node: SvAST.SvelteAttribute): string | null;
+export declare function getLangValue(node: SvAST.SvelteScriptElement | SvAST.SvelteStyleElement): string | null;
+export declare function findVariable(context: RuleContext, node: TSESTree.Identifier): Variable | null;
+export declare function iterateIdentifiers(node: TSESTree.DestructuringPattern): Iterable<TSESTree.Identifier>;
+export declare function getScope(context: RuleContext, currentNode: TSESTree.Node): Scope;
+export declare function getParent(node: TSESTree.Node): TSESTree.Node | null;
+export type QuoteAndRange = {
+    quote: 'unquoted' | 'double' | 'single';
+    range: [number, number];
+    firstToken: SvAST.Token | SvAST.Comment;
+    lastToken: SvAST.Token | SvAST.Comment;
+};
+export declare function getAttributeValueQuoteAndRange(attr: SvAST.SvelteAttribute | SvAST.SvelteDirective | SvAST.SvelteStyleDirective | SvAST.SvelteSpecialDirective, sourceCode: SourceCode): QuoteAndRange | null;
+export declare function getMustacheTokens(node: SvAST.SvelteMustacheTag | SvAST.SvelteShorthandAttribute | SvAST.SvelteSpreadAttribute | SvAST.SvelteDebugTag, sourceCode: SourceCode): {
+    openToken: SvAST.Token;
+    closeToken: SvAST.Token;
+};
+export declare function getMustacheTokens(node: SvAST.SvelteDirective | SvAST.SvelteSpecialDirective | SvAST.SvelteMustacheTag | SvAST.SvelteShorthandAttribute | SvAST.SvelteSpreadAttribute | SvAST.SvelteDebugTag, sourceCode: SourceCode): {
+    openToken: SvAST.Token;
+    closeToken: SvAST.Token;
+} | null;
+export declare function getAttributeKeyText(node: SvAST.SvelteAttribute | SvAST.SvelteShorthandAttribute | SvAST.SvelteStyleDirective | SvAST.SvelteDirective | SvAST.SvelteSpecialDirective, context: RuleContext): string;
+export declare function getDirectiveName(node: SvAST.SvelteDirective): string;
+export declare function getNodeName(node: SvAST.SvelteElement): string;
+export declare function isVoidHtmlElement(node: SvAST.SvelteElement): boolean;
+export declare function isExpressionIdentifier(node: TSESTree.Identifier): boolean;

node_modules/eslint-plugin-svelte/lib/utils/ast-utils.js

@@ -0,0 +1,430 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExpressionIdentifier = exports.isVoidHtmlElement = exports.getNodeName = exports.getDirectiveName = exports.getAttributeKeyText = exports.getMustacheTokens = exports.getAttributeValueQuoteAndRange = exports.getParent = exports.getScope = exports.iterateIdentifiers = exports.findVariable = exports.getLangValue = exports.getStaticAttributeValue = exports.findBindDirective = exports.findShorthandAttribute = exports.findAttribute = exports.isHTMLElementLike = exports.needParentheses = exports.getStringIfConstant = exports.equalTokens = void 0;
+const eslintUtils = __importStar(require("@eslint-community/eslint-utils"));
+const void_elements_1 = __importDefault(require("./void-elements"));
+const compat_1 = require("./compat");
+function equalTokens(left, right, sourceCode) {
+    const tokensL = sourceCode.getTokens(left);
+    const tokensR = sourceCode.getTokens(right);
+    if (tokensL.length !== tokensR.length) {
+        return false;
+    }
+    for (let i = 0; i < tokensL.length; ++i) {
+        if (tokensL[i].type !== tokensR[i].type || tokensL[i].value !== tokensR[i].value) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.equalTokens = equalTokens;
+function getStringIfConstant(node) {
+    if (node.type === 'Literal') {
+        if (typeof node.value === 'string')
+            return node.value;
+    }
+    else if (node.type === 'TemplateLiteral') {
+        let str = '';
+        const quasis = [...node.quasis];
+        const expressions = [...node.expressions];
+        let quasi, expr;
+        while ((quasi = quasis.shift())) {
+            str += quasi.value.cooked;
+            expr = expressions.shift();
+            if (expr) {
+                const exprStr = getStringIfConstant(expr);
+                if (exprStr == null) {
+                    return null;
+                }
+                str += exprStr;
+            }
+        }
+        return str;
+    }
+    else if (node.type === 'BinaryExpression') {
+        if (node.operator === '+') {
+            const left = getStringIfConstant(node.left);
+            if (left == null) {
+                return null;
+            }
+            const right = getStringIfConstant(node.right);
+            if (right == null) {
+                return null;
+            }
+            return left + right;
+        }
+    }
+    return null;
+}
+exports.getStringIfConstant = getStringIfConstant;
+function needParentheses(node, kind) {
+    if (node.type === 'ArrowFunctionExpression' ||
+        node.type === 'AssignmentExpression' ||
+        node.type === 'BinaryExpression' ||
+        node.type === 'ConditionalExpression' ||
+        node.type === 'LogicalExpression' ||
+        node.type === 'SequenceExpression' ||
+        node.type === 'UnaryExpression' ||
+        node.type === 'UpdateExpression')
+        return true;
+    if (kind === 'logical') {
+        return node.type === 'FunctionExpression';
+    }
+    return false;
+}
+exports.needParentheses = needParentheses;
+function isHTMLElementLike(node) {
+    if (node.type !== 'SvelteElement') {
+        return false;
+    }
+    switch (node.kind) {
+        case 'html':
+            return true;
+        case 'special':
+            return node.name.name === 'svelte:element';
+        default:
+            return false;
+    }
+}
+exports.isHTMLElementLike = isHTMLElementLike;
+function findAttribute(node, name) {
+    const startTag = node.type === 'SvelteStartTag' ? node : node.startTag;
+    for (const attr of startTag.attributes) {
+        if (attr.type === 'SvelteAttribute') {
+            if (attr.key.name === name) {
+                return attr;
+            }
+        }
+    }
+    return null;
+}
+exports.findAttribute = findAttribute;
+function findShorthandAttribute(node, name) {
+    const startTag = node.type === 'SvelteStartTag' ? node : node.startTag;
+    for (const attr of startTag.attributes) {
+        if (attr.type === 'SvelteShorthandAttribute') {
+            if (attr.key.name === name) {
+                return attr;
+            }
+        }
+    }
+    return null;
+}
+exports.findShorthandAttribute = findShorthandAttribute;
+function findBindDirective(node, name) {
+    const startTag = node.type === 'SvelteStartTag' ? node : node.startTag;
+    for (const attr of startTag.attributes) {
+        if (attr.type === 'SvelteDirective') {
+            if (attr.kind === 'Binding' && attr.key.name.name === name) {
+                return attr;
+            }
+        }
+    }
+    return null;
+}
+exports.findBindDirective = findBindDirective;
+function getStaticAttributeValue(node) {
+    let str = '';
+    for (const value of node.value) {
+        if (value.type === 'SvelteLiteral') {
+            str += value.value;
+        }
+        else {
+            return null;
+        }
+    }
+    return str;
+}
+exports.getStaticAttributeValue = getStaticAttributeValue;
+function getLangValue(node) {
+    const langAttr = findAttribute(node, 'lang');
+    return langAttr && getStaticAttributeValue(langAttr);
+}
+exports.getLangValue = getLangValue;
+function findVariable(context, node) {
+    const initialScope = eslintUtils.getInnermostScope(getScope(context, node), node);
+    const variable = eslintUtils.findVariable(initialScope, node);
+    if (variable) {
+        return variable;
+    }
+    if (!node.name.startsWith('$')) {
+        return variable;
+    }
+    return eslintUtils.findVariable(initialScope, node.name.slice(1));
+}
+exports.findVariable = findVariable;
+function* iterateIdentifiers(node) {
+    const buffer = [node];
+    let pattern;
+    while ((pattern = buffer.shift())) {
+        if (pattern.type === 'Identifier') {
+            yield pattern;
+        }
+        else if (pattern.type === 'ArrayPattern') {
+            for (const element of pattern.elements) {
+                if (element) {
+                    buffer.push(element);
+                }
+            }
+        }
+        else if (pattern.type === 'ObjectPattern') {
+            for (const property of pattern.properties) {
+                if (property.type === 'Property') {
+                    buffer.push(property.value);
+                }
+                else if (property.type === 'RestElement') {
+                    buffer.push(property);
+                }
+            }
+        }
+        else if (pattern.type === 'AssignmentPattern') {
+            buffer.push(pattern.left);
+        }
+        else if (pattern.type === 'RestElement') {
+            buffer.push(pattern.argument);
+        }
+        else if (pattern.type === 'MemberExpression') {
+        }
+    }
+}
+exports.iterateIdentifiers = iterateIdentifiers;
+function getScope(context, currentNode) {
+    const scopeManager = (0, compat_1.getSourceCode)(context).scopeManager;
+    let node = currentNode;
+    for (; node; node = node.parent || null) {
+        const scope = scopeManager.acquire(node, false);
+        if (scope) {
+            if (scope.type === 'function-expression-name') {
+                return scope.childScopes[0];
+            }
+            return scope;
+        }
+    }
+    return scopeManager.scopes[0];
+}
+exports.getScope = getScope;
+function getParent(node) {
+    return node.parent || null;
+}
+exports.getParent = getParent;
+function getAttributeValueQuoteAndRange(attr, sourceCode) {
+    const valueTokens = getAttributeValueRangeTokens(attr, sourceCode);
+    if (valueTokens == null) {
+        return null;
+    }
+    const { firstToken: valueFirstToken, lastToken: valueLastToken } = valueTokens;
+    const eqToken = sourceCode.getTokenAfter(attr.key);
+    if (!eqToken || eqToken.value !== '=' || valueFirstToken.range[0] < eqToken.range[1]) {
+        return null;
+    }
+    const beforeTokens = sourceCode.getTokensBetween(eqToken, valueFirstToken);
+    if (beforeTokens.length === 0) {
+        return {
+            quote: 'unquoted',
+            range: [valueFirstToken.range[0], valueLastToken.range[1]],
+            firstToken: valueFirstToken,
+            lastToken: valueLastToken
+        };
+    }
+    else if (beforeTokens.length > 1 ||
+        (beforeTokens[0].value !== '"' && beforeTokens[0].value !== "'")) {
+        return null;
+    }
+    const beforeToken = beforeTokens[0];
+    const afterToken = sourceCode.getTokenAfter(valueLastToken);
+    if (!afterToken || afterToken.value !== beforeToken.value) {
+        return null;
+    }
+    return {
+        quote: beforeToken.value === '"' ? 'double' : 'single',
+        range: [beforeToken.range[0], afterToken.range[1]],
+        firstToken: beforeToken,
+        lastToken: afterToken
+    };
+}
+exports.getAttributeValueQuoteAndRange = getAttributeValueQuoteAndRange;
+function getMustacheTokens(node, sourceCode) {
+    if (node.type === 'SvelteMustacheTag' ||
+        node.type === 'SvelteShorthandAttribute' ||
+        node.type === 'SvelteSpreadAttribute' ||
+        node.type === 'SvelteDebugTag') {
+        const openToken = sourceCode.getFirstToken(node);
+        const closeToken = sourceCode.getLastToken(node);
+        return {
+            openToken,
+            closeToken
+        };
+    }
+    if (node.expression == null) {
+        return null;
+    }
+    if (node.key.range[0] <= node.expression.range[0] &&
+        node.expression.range[1] <= node.key.range[1]) {
+        return null;
+    }
+    let openToken = sourceCode.getTokenBefore(node.expression);
+    let closeToken = sourceCode.getTokenAfter(node.expression);
+    while (openToken &&
+        closeToken &&
+        eslintUtils.isOpeningParenToken(openToken) &&
+        eslintUtils.isClosingParenToken(closeToken)) {
+        openToken = sourceCode.getTokenBefore(openToken);
+        closeToken = sourceCode.getTokenAfter(closeToken);
+    }
+    if (!openToken ||
+        !closeToken ||
+        eslintUtils.isNotOpeningBraceToken(openToken) ||
+        eslintUtils.isNotClosingBraceToken(closeToken)) {
+        return null;
+    }
+    return {
+        openToken,
+        closeToken
+    };
+}
+exports.getMustacheTokens = getMustacheTokens;
+function getAttributeKeyText(node, context) {
+    switch (node.type) {
+        case 'SvelteAttribute':
+        case 'SvelteShorthandAttribute':
+            return node.key.name;
+        case 'SvelteStyleDirective':
+            return `style:${node.key.name.name}`;
+        case 'SvelteSpecialDirective':
+            return node.kind;
+        case 'SvelteDirective': {
+            const dir = getDirectiveName(node);
+            return `${dir}:${getSimpleNameFromNode(node.key.name, context)}${node.key.modifiers.length ? `|${node.key.modifiers.join('|')}` : ''}`;
+        }
+        default:
+            throw new Error(`Unknown node type: ${node.type}`);
+    }
+}
+exports.getAttributeKeyText = getAttributeKeyText;
+function getDirectiveName(node) {
+    switch (node.kind) {
+        case 'Action':
+            return 'use';
+        case 'Animation':
+            return 'animate';
+        case 'Binding':
+            return 'bind';
+        case 'Class':
+            return 'class';
+        case 'EventHandler':
+            return 'on';
+        case 'Let':
+            return 'let';
+        case 'Transition':
+            return node.intro && node.outro ? 'transition' : node.intro ? 'in' : 'out';
+        case 'Ref':
+            return 'ref';
+        default:
+            throw new Error('Unknown directive kind');
+    }
+}
+exports.getDirectiveName = getDirectiveName;
+function getAttributeValueRangeTokens(attr, sourceCode) {
+    if (attr.type === 'SvelteAttribute' || attr.type === 'SvelteStyleDirective') {
+        if (!attr.value.length) {
+            return null;
+        }
+        const first = attr.value[0];
+        const last = attr.value[attr.value.length - 1];
+        return {
+            firstToken: sourceCode.getFirstToken(first),
+            lastToken: sourceCode.getLastToken(last)
+        };
+    }
+    const tokens = getMustacheTokens(attr, sourceCode);
+    if (!tokens) {
+        return null;
+    }
+    return {
+        firstToken: tokens.openToken,
+        lastToken: tokens.closeToken
+    };
+}
+function getNodeName(node) {
+    return getSimpleNameFromNode(node.name);
+}
+exports.getNodeName = getNodeName;
+function isVoidHtmlElement(node) {
+    return void_elements_1.default.includes(getNodeName(node));
+}
+exports.isVoidHtmlElement = isVoidHtmlElement;
+function isExpressionIdentifier(node) {
+    const parent = node.parent;
+    if (!parent) {
+        return true;
+    }
+    if (parent.type === 'MemberExpression') {
+        return !parent.computed || parent.property !== node;
+    }
+    if (parent.type === 'Property' ||
+        parent.type === 'MethodDefinition' ||
+        parent.type === 'PropertyDefinition') {
+        return !parent.computed || parent.key !== node;
+    }
+    if (parent.type === 'FunctionDeclaration' ||
+        parent.type === 'FunctionExpression' ||
+        parent.type === 'ClassDeclaration' ||
+        parent.type === 'ClassExpression') {
+        return parent.id !== node;
+    }
+    if (parent.type === 'LabeledStatement' ||
+        parent.type === 'BreakStatement' ||
+        parent.type === 'ContinueStatement') {
+        return parent.label !== node;
+    }
+    if (parent.type === 'MetaProperty') {
+        return parent.property !== node;
+    }
+    if (parent.type === 'ImportSpecifier') {
+        return parent.imported !== node;
+    }
+    if (parent.type === 'ExportSpecifier') {
+        return parent.exported !== node;
+    }
+    return true;
+}
+exports.isExpressionIdentifier = isExpressionIdentifier;
+function getSimpleNameFromNode(node, context) {
+    if (node.type === 'Identifier' || node.type === 'SvelteName') {
+        return node.name;
+    }
+    if (node.type === 'SvelteMemberExpressionName' ||
+        (node.type === 'MemberExpression' && !node.computed)) {
+        return `${getSimpleNameFromNode(node.object, context)}.${getSimpleNameFromNode(node.property, context)}`;
+    }
+    if (!context) {
+        throw new Error('Rule context is required');
+    }
+    return (0, compat_1.getSourceCode)(context).getText(node);
+}

node_modules/eslint-plugin-svelte/lib/utils/cache.d.ts

@@ -0,0 +1,4 @@
+export declare function createCache<T>(): {
+    get: (key: string) => T | null;
+    set: (key: string, value: T) => void;
+};

node_modules/eslint-plugin-svelte/lib/utils/cache.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCache = void 0;
+const SKIP_TIME = 5000;
+function createCache() {
+    const map = new Map();
+    function get(key) {
+        const entry = map.get(key);
+        const now = Date.now();
+        if (entry) {
+            if (entry.expire > now) {
+                entry.expire = now + SKIP_TIME;
+                return entry.value;
+            }
+            map.delete(key);
+        }
+        return null;
+    }
+    function set(key, value) {
+        const entry = map.get(key);
+        const expire = Date.now() + SKIP_TIME;
+        if (entry) {
+            entry.value = value;
+            entry.expire = expire;
+        }
+        else {
+            map.set(key, { value, expire });
+        }
+    }
+    return { get, set };
+}
+exports.createCache = createCache;

node_modules/eslint-plugin-svelte/lib/utils/compat.d.ts

@@ -0,0 +1,5 @@
+import type { RuleContext, SourceCode } from '../types';
+export declare function getSourceCode(context: RuleContext): SourceCode;
+export declare function getFilename(context: RuleContext): string;
+export declare function getPhysicalFilename(context: RuleContext): string;
+export declare function getCwd(context: RuleContext): string;

node_modules/eslint-plugin-svelte/lib/utils/compat.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCwd = exports.getPhysicalFilename = exports.getFilename = exports.getSourceCode = void 0;
+const eslint_compat_utils_1 = require("eslint-compat-utils");
+function getSourceCode(context) {
+    return (0, eslint_compat_utils_1.getSourceCode)(context);
+}
+exports.getSourceCode = getSourceCode;
+function getFilename(context) {
+    return (0, eslint_compat_utils_1.getFilename)(context);
+}
+exports.getFilename = getFilename;
+function getPhysicalFilename(context) {
+    return (0, eslint_compat_utils_1.getPhysicalFilename)(context);
+}
+exports.getPhysicalFilename = getPhysicalFilename;
+function getCwd(context) {
+    return (0, eslint_compat_utils_1.getCwd)(context);
+}
+exports.getCwd = getCwd;

node_modules/eslint-plugin-svelte/lib/utils/css-utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './style-attribute';
+export * from './resource';
+export * from './utils';

node_modules/eslint-plugin-svelte/lib/utils/css-utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./style-attribute"), exports);
+__exportStar(require("./resource"), exports);
+__exportStar(require("./utils"), exports);

node_modules/eslint-plugin-svelte/lib/utils/css-utils/resource.d.ts

@@ -0,0 +1 @@
+export declare const SHORTHAND_PROPERTIES: Map<string, string[]>;

node_modules/eslint-plugin-svelte/lib/utils/css-utils/resource.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHORTHAND_PROPERTIES = void 0;
+exports.SHORTHAND_PROPERTIES = new Map([
+    ['margin', ['margin-top', 'margin-bottom', 'margin-left', 'margin-right']],
+    ['padding', ['padding-top', 'padding-bottom', 'padding-left', 'padding-right']],
+    [
+        'background',
+        [
+            'background-image',
+            'background-size',
+            'background-position',
+            'background-repeat',
+            'background-origin',
+            'background-clip',
+            'background-attachment',
+            'background-color'
+        ]
+    ],
+    [
+        'font',
+        [
+            'font-style',
+            'font-variant',
+            'font-weight',
+            'font-stretch',
+            'font-size',
+            'font-family',
+            'line-height'
+        ]
+    ],
+    [
+        'border',
+        [
+            'border-top-width',
+            'border-bottom-width',
+            'border-left-width',
+            'border-right-width',
+            'border-top-style',
+            'border-bottom-style',
+            'border-left-style',
+            'border-right-style',
+            'border-top-color',
+            'border-bottom-color',
+            'border-left-color',
+            'border-right-color'
+        ]
+    ],
+    ['border-top', ['border-top-width', 'border-top-style', 'border-top-color']],
+    ['border-bottom', ['border-bottom-width', 'border-bottom-style', 'border-bottom-color']],
+    ['border-left', ['border-left-width', 'border-left-style', 'border-left-color']],
+    ['border-right', ['border-right-width', 'border-right-style', 'border-right-color']],
+    [
+        'border-width',
+        ['border-top-width', 'border-bottom-width', 'border-left-width', 'border-right-width']
+    ],
+    [
+        'border-style',
+        ['border-top-style', 'border-bottom-style', 'border-left-style', 'border-right-style']
+    ],
+    [
+        'border-color',
+        ['border-top-color', 'border-bottom-color', 'border-left-color', 'border-right-color']
+    ],
+    ['list-style', ['list-style-type', 'list-style-position', 'list-style-image']],
+    [
+        'border-radius',
+        [
+            'border-top-right-radius',
+            'border-top-left-radius',
+            'border-bottom-right-radius',
+            'border-bottom-left-radius'
+        ]
+    ],
+    [
+        'transition',
+        ['transition-delay', 'transition-duration', 'transition-property', 'transition-timing-function']
+    ],
+    [
+        'animation',
+        [
+            'animation-name',
+            'animation-duration',
+            'animation-timing-function',
+            'animation-delay',
+            'animation-iteration-count',
+            'animation-direction',
+            'animation-fill-mode',
+            'animation-play-state'
+        ]
+    ],
+    [
+        'border-block-end',
+        ['border-block-end-width', 'border-block-end-style', 'border-block-end-color']
+    ],
+    [
+        'border-block-start',
+        ['border-block-start-width', 'border-block-start-style', 'border-block-start-color']
+    ],
+    [
+        'border-image',
+        [
+            'border-image-source',
+            'border-image-slice',
+            'border-image-width',
+            'border-image-outset',
+            'border-image-repeat'
+        ]
+    ],
+    [
+        'border-inline-end',
+        ['border-inline-end-width', 'border-inline-end-style', 'border-inline-end-color']
+    ],
+    [
+        'border-inline-start',
+        ['border-inline-start-width', 'border-inline-start-style', 'border-inline-start-color']
+    ],
+    ['column-rule', ['column-rule-width', 'column-rule-style', 'column-rule-color']],
+    ['columns', ['column-width', 'column-count']],
+    ['flex', ['flex-grow', 'flex-shrink', 'flex-basis']],
+    ['flex-flow', ['flex-direction', 'flex-wrap']],
+    [
+        'grid',
+        [
+            'grid-template-rows',
+            'grid-template-columns',
+            'grid-template-areas',
+            'grid-auto-rows',
+            'grid-auto-columns',
+            'grid-auto-flow',
+            'grid-column-gap',
+            'grid-row-gap'
+        ]
+    ],
+    ['grid-area', ['grid-row-start', 'grid-column-start', 'grid-row-end', 'grid-column-end']],
+    ['grid-column', ['grid-column-start', 'grid-column-end']],
+    ['grid-gap', ['grid-row-gap', 'grid-column-gap']],
+    ['grid-row', ['grid-row-start', 'grid-row-end']],
+    ['grid-template', ['grid-template-columns', 'grid-template-rows', 'grid-template-areas']],
+    ['outline', ['outline-color', 'outline-style', 'outline-width']],
+    ['text-decoration', ['text-decoration-color', 'text-decoration-style', 'text-decoration-line']],
+    ['text-emphasis', ['text-emphasis-style', 'text-emphasis-color']],
+    [
+        'mask',
+        [
+            'mask-image',
+            'mask-mode',
+            'mask-position',
+            'mask-size',
+            'mask-repeat',
+            'mask-origin',
+            'mask-clip',
+            'mask-composite'
+        ]
+    ]
+]);

node_modules/eslint-plugin-svelte/lib/utils/css-utils/style-attribute.d.ts

@@ -0,0 +1,43 @@
+import type { AST } from 'svelte-eslint-parser';
+import type { RuleContext } from '../../types';
+import type { TSESTree } from '@typescript-eslint/types';
+export declare function parseStyleAttributeValue(node: AST.SvelteAttribute, context: RuleContext): SvelteStyleRoot<AST.SvelteMustacheTagText> | null;
+export type SvelteStyleInterpolation = AST.SvelteMustacheTagText | TSESTree.Expression;
+export interface SvelteStyleNode<E extends SvelteStyleInterpolation> {
+    nodes?: SvelteStyleChildNode<E>[];
+    range: AST.Range;
+    loc: AST.SourceLocation;
+}
+export interface SvelteStyleRoot<E extends SvelteStyleInterpolation = SvelteStyleInterpolation> {
+    type: 'root';
+    nodes: (SvelteStyleChildNode<E> | SvelteStyleInline<E>)[];
+}
+export interface SvelteStyleInline<E extends SvelteStyleInterpolation = SvelteStyleInterpolation> extends SvelteStyleNode<E> {
+    type: 'inline';
+    node: E;
+    getInlineStyle(node: TSESTree.Expression): SvelteStyleRoot<TSESTree.Expression> | null;
+    getAllInlineStyles(): Map<TSESTree.Expression, SvelteStyleRoot<TSESTree.Expression>>;
+}
+export interface SvelteStyleDeclaration<E extends SvelteStyleInterpolation = SvelteStyleInterpolation> extends SvelteStyleNode<E> {
+    type: 'decl';
+    prop: {
+        name: string;
+        range: AST.Range;
+        loc: AST.SourceLocation;
+        interpolations: E[];
+    };
+    value: {
+        value: string;
+        range: AST.Range;
+        loc: AST.SourceLocation;
+        interpolations: E[];
+    };
+    important: boolean;
+    addInterpolation: (tagOrExpr: E) => void;
+    unknownInterpolations: E[];
+}
+export interface SvelteStyleComment extends SvelteStyleNode<never> {
+    type: 'comment';
+    addInterpolation: (tagOrExpr: SvelteStyleInterpolation) => void;
+}
+export type SvelteStyleChildNode<E extends SvelteStyleInterpolation = SvelteStyleInterpolation> = SvelteStyleDeclaration<E> | SvelteStyleComment;

node_modules/eslint-plugin-svelte/lib/utils/css-utils/style-attribute.js

@@ -0,0 +1,261 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStyleAttributeValue = void 0;
+const template_safe_parser_1 = __importDefault(require("./template-safe-parser"));
+const postcss_1 = require("postcss");
+const compat_1 = require("../compat");
+function safeParseCss(css) {
+    try {
+        const input = new postcss_1.Input(css);
+        const parser = new template_safe_parser_1.default(input);
+        parser.parse();
+        return parser.root;
+    }
+    catch {
+        return null;
+    }
+}
+const cache = new WeakMap();
+function parseStyleAttributeValue(node, context) {
+    if (cache.has(node)) {
+        return cache.get(node) || null;
+    }
+    cache.set(node, null);
+    if (!node.value?.length) {
+        return null;
+    }
+    const startOffset = node.value[0].range[0];
+    const sourceCode = (0, compat_1.getSourceCode)(context);
+    const cssCode = node.value.map((value) => sourceCode.getText(value)).join('');
+    const root = safeParseCss(cssCode);
+    if (!root) {
+        return root;
+    }
+    const ctx = {
+        startOffset,
+        value: node.value,
+        context
+    };
+    const mustacheTags = node.value.filter((v) => v.type === 'SvelteMustacheTag');
+    const converted = convertRoot(root, mustacheTags, (e) => e.range, ctx);
+    cache.set(node, converted);
+    return converted;
+}
+exports.parseStyleAttributeValue = parseStyleAttributeValue;
+class IgnoreError extends Error {
+}
+function isStringLiteral(node) {
+    return node.type === 'Literal' && typeof node.value === 'string';
+}
+function convertRoot(root, interpolations, getRange, ctx) {
+    const nodes = [];
+    for (const child of root.nodes) {
+        const converted = convertChild(child, ctx);
+        if (!converted) {
+            return null;
+        }
+        while (interpolations[0]) {
+            const tagOrExpr = interpolations[0];
+            if (tagOrExpr.range[1] <= converted.range[0]) {
+                nodes.push(buildSvelteStyleInline(tagOrExpr));
+                interpolations.shift();
+                continue;
+            }
+            if (tagOrExpr.range[0] < converted.range[1]) {
+                try {
+                    converted.addInterpolation(tagOrExpr);
+                }
+                catch (e) {
+                    if (e instanceof IgnoreError)
+                        return null;
+                    throw e;
+                }
+                interpolations.shift();
+                continue;
+            }
+            break;
+        }
+        nodes.push(converted);
+    }
+    nodes.push(...interpolations.map(buildSvelteStyleInline));
+    return {
+        type: 'root',
+        nodes
+    };
+    function buildSvelteStyleInline(tagOrExpr) {
+        const inlineStyles = new Map();
+        let range = null;
+        function getRangeForInline() {
+            if (range) {
+                return range;
+            }
+            return range ?? (range = getRange(tagOrExpr));
+        }
+        return {
+            type: 'inline',
+            node: tagOrExpr,
+            get range() {
+                return getRangeForInline();
+            },
+            get loc() {
+                return toLoc(getRangeForInline(), ctx);
+            },
+            getInlineStyle(node) {
+                return getInlineStyle(node);
+            },
+            getAllInlineStyles() {
+                const allInlineStyles = new Map();
+                for (const node of extractExpressions(tagOrExpr)) {
+                    const style = getInlineStyle(node);
+                    if (style) {
+                        allInlineStyles.set(node, style);
+                    }
+                }
+                return allInlineStyles;
+            }
+        };
+        function getInlineStyle(node) {
+            if (node.type === 'SvelteMustacheTag') {
+                return getInlineStyle(node.expression);
+            }
+            if (inlineStyles.has(node)) {
+                return inlineStyles.get(node) || null;
+            }
+            const sourceCode = (0, compat_1.getSourceCode)(ctx.context);
+            inlineStyles.set(node, null);
+            let converted;
+            if (isStringLiteral(node)) {
+                const root = safeParseCss(sourceCode.getText(node).slice(1, -1));
+                if (!root) {
+                    return null;
+                }
+                converted = convertRoot(root, [], () => [0, 0], {
+                    ...ctx,
+                    startOffset: node.range[0] + 1
+                });
+            }
+            else if (node.type === 'TemplateLiteral') {
+                const root = safeParseCss(sourceCode.getText(node).slice(1, -1));
+                if (!root) {
+                    return null;
+                }
+                converted = convertRoot(root, [...node.expressions], (e) => {
+                    const index = node.expressions.indexOf(e);
+                    return [node.quasis[index].range[1] - 2, node.quasis[index + 1].range[0] + 1];
+                }, {
+                    ...ctx,
+                    startOffset: node.range[0] + 1
+                });
+            }
+            else {
+                return null;
+            }
+            inlineStyles.set(node, converted);
+            return converted;
+        }
+        function* extractExpressions(node) {
+            if (node.type === 'SvelteMustacheTag') {
+                yield* extractExpressions(node.expression);
+            }
+            else if (isStringLiteral(node)) {
+                yield node;
+            }
+            else if (node.type === 'TemplateLiteral') {
+                yield node;
+            }
+            else if (node.type === 'ConditionalExpression') {
+                yield* extractExpressions(node.consequent);
+                yield* extractExpressions(node.alternate);
+            }
+            else if (node.type === 'LogicalExpression') {
+                yield* extractExpressions(node.left);
+                yield* extractExpressions(node.right);
+            }
+        }
+    }
+}
+function convertChild(node, ctx) {
+    const range = convertRange(node, ctx);
+    if (node.type === 'decl') {
+        const propRange = [range[0], range[0] + node.prop.length];
+        const declValueStartIndex = propRange[1] + (node.raws.between || '').length;
+        const valueRange = [
+            declValueStartIndex,
+            declValueStartIndex + (node.raws.value?.value || node.value).length
+        ];
+        const prop = {
+            name: node.prop,
+            range: propRange,
+            get loc() {
+                return toLoc(propRange, ctx);
+            },
+            interpolations: []
+        };
+        const value = {
+            value: node.value,
+            range: valueRange,
+            get loc() {
+                return toLoc(valueRange, ctx);
+            },
+            interpolations: []
+        };
+        const unknownInterpolations = [];
+        return {
+            type: 'decl',
+            prop,
+            value,
+            important: node.important,
+            range,
+            get loc() {
+                return toLoc(range, ctx);
+            },
+            addInterpolation(tagOrExpr) {
+                const index = tagOrExpr.range[0];
+                if (prop.range[0] <= index && index < prop.range[1]) {
+                    prop.interpolations.push(tagOrExpr);
+                    return;
+                }
+                if (value.range[0] <= index && index < value.range[1]) {
+                    value.interpolations.push(tagOrExpr);
+                    return;
+                }
+                unknownInterpolations.push(tagOrExpr);
+            },
+            unknownInterpolations
+        };
+    }
+    if (node.type === 'comment') {
+        return {
+            type: 'comment',
+            range,
+            get loc() {
+                return toLoc(range, ctx);
+            },
+            addInterpolation: () => {
+                throw new IgnoreError();
+            }
+        };
+    }
+    if (node.type === 'atrule') {
+        return null;
+    }
+    if (node.type === 'rule') {
+        return null;
+    }
+    return null;
+}
+function convertRange(node, ctx) {
+    return [
+        ctx.startOffset + node.source.start.offset,
+        ctx.startOffset + node.source.end.offset + 1
+    ];
+}
+function toLoc(range, ctx) {
+    return {
+        start: (0, compat_1.getSourceCode)(ctx.context).getLocFromIndex(range[0]),
+        end: (0, compat_1.getSourceCode)(ctx.context).getLocFromIndex(range[1])
+    };
+}

node_modules/eslint-plugin-svelte/lib/utils/css-utils/template-safe-parser.d.ts

@@ -0,0 +1,5 @@
+import SafeParser from 'postcss-safe-parser/lib/safe-parser';
+declare class TemplateSafeParser extends SafeParser {
+    protected createTokenizer(): void;
+}
+export default TemplateSafeParser;

node_modules/eslint-plugin-svelte/lib/utils/css-utils/template-safe-parser.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const safe_parser_1 = __importDefault(require("postcss-safe-parser/lib/safe-parser"));
+const template_tokenize_1 = __importDefault(require("./template-tokenize"));
+class TemplateSafeParser extends safe_parser_1.default {
+    createTokenizer() {
+        this.tokenizer = (0, template_tokenize_1.default)(this.input, { ignoreErrors: true });
+    }
+}
+exports.default = TemplateSafeParser;

node_modules/eslint-plugin-svelte/lib/utils/css-utils/template-tokenize.d.ts

@@ -0,0 +1,5 @@
+import type { Tokenizer } from 'postcss/lib/tokenize';
+import tokenize from 'postcss/lib/tokenize';
+type Tokenize = typeof tokenize;
+declare function templateTokenize(...args: Parameters<Tokenize>): Tokenizer;
+export default templateTokenize;

node_modules/eslint-plugin-svelte/lib/utils/css-utils/template-tokenize.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const tokenize_1 = __importDefault(require("postcss/lib/tokenize"));
+function templateTokenize(...args) {
+    const tokenizer = (0, tokenize_1.default)(...args);
+    function nextToken(...args) {
+        const returned = [];
+        let token, lastPos;
+        let depth = 0;
+        while ((token = tokenizer.nextToken(...args))) {
+            if (token[0] !== 'word') {
+                if (token[0] === '{') {
+                    ++depth;
+                }
+                else if (token[0] === '}') {
+                    --depth;
+                }
+            }
+            if (depth || returned.length) {
+                lastPos = token[3] || token[2] || lastPos;
+                returned.push(token);
+            }
+            if (!depth) {
+                break;
+            }
+        }
+        if (returned.length) {
+            token = ['word', returned.map((token) => token[1]).join(''), returned[0][2], lastPos];
+        }
+        return token;
+    }
+    return Object.assign({}, tokenizer, {
+        nextToken
+    });
+}
+exports.default = templateTokenize;

node_modules/eslint-plugin-svelte/lib/utils/css-utils/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function hasVendorPrefix(prop: string): boolean;
+export declare function getVendorPrefix(prop: string): string;
+export declare function stripVendorPrefix(prop: string): string;

node_modules/eslint-plugin-svelte/lib/utils/css-utils/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripVendorPrefix = exports.getVendorPrefix = exports.hasVendorPrefix = void 0;
+function hasVendorPrefix(prop) {
+    return Boolean(getVendorPrefix(prop));
+}
+exports.hasVendorPrefix = hasVendorPrefix;
+function getVendorPrefix(prop) {
+    return /^-\w+-/u.exec(prop)?.[0] || '';
+}
+exports.getVendorPrefix = getVendorPrefix;
+function stripVendorPrefix(prop) {
+    return prop.slice(getVendorPrefix(prop).length);
+}
+exports.stripVendorPrefix = stripVendorPrefix;

node_modules/eslint-plugin-svelte/lib/utils/eslint-core.d.ts

@@ -0,0 +1,13 @@
+import type { RuleListener, RuleContext, RuleModule } from '../types';
+import type { TSESTree } from '@typescript-eslint/types';
+import type { AST as SvAST } from 'svelte-eslint-parser';
+export declare function defineWrapperListener(coreRule: RuleModule, context: RuleContext, proxyOptions: {
+    createListenerProxy?: (listener: RuleListener) => RuleListener;
+}): RuleListener;
+export declare function getProxyNode(node: {
+    type: string;
+}, properties: any): any;
+export declare function buildProxyListener(base: RuleListener, convertNode: (node: SvAST.SvelteNode | (TSESTree.Node & {
+    parent: SvAST.SvelteNode | TSESTree.Node | null;
+})) => any): RuleListener;
+export declare function getCoreRule(ruleName: string): RuleModule;

node_modules/eslint-plugin-svelte/lib/utils/eslint-core.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCoreRule = exports.buildProxyListener = exports.getProxyNode = exports.defineWrapperListener = void 0;
+const eslint_1 = require("eslint");
+function defineWrapperListener(coreRule, context, proxyOptions) {
+    const listener = coreRule.create(context);
+    const svelteListener = proxyOptions.createListenerProxy?.(listener) ?? listener;
+    return svelteListener;
+}
+exports.defineWrapperListener = defineWrapperListener;
+function getProxyNode(node, properties) {
+    const cache = {};
+    return new Proxy(node, {
+        get(_t, key) {
+            if (key in cache) {
+                return cache[key];
+            }
+            if (key in properties) {
+                return (cache[key] = properties[key]);
+            }
+            return node[key];
+        }
+    });
+}
+exports.getProxyNode = getProxyNode;
+function buildProxyListener(base, convertNode) {
+    const listeners = {};
+    for (const [key, listener] of Object.entries(base)) {
+        listeners[key] = function (...args) {
+            listener.call(this, ...args.map((arg) => {
+                if (typeof arg === 'object' &&
+                    'type' in arg &&
+                    typeof arg.type === 'string' &&
+                    'range' in arg) {
+                    return convertNode(arg);
+                }
+                return arg;
+            }));
+        };
+    }
+    return listeners;
+}
+exports.buildProxyListener = buildProxyListener;
+let ruleMap = null;
+function getCoreRule(ruleName) {
+    let map;
+    if (ruleMap) {
+        map = ruleMap;
+    }
+    else {
+        ruleMap = map = new eslint_1.Linter().getRules();
+    }
+    return map.get(ruleName);
+}
+exports.getCoreRule = getCoreRule;

node_modules/eslint-plugin-svelte/lib/utils/get-package-json.d.ts

@@ -0,0 +1,12 @@
+type PackageJson = {
+    name?: unknown;
+    dependencies?: {
+        [key in string]?: unknown;
+    };
+    devDependencies?: {
+        [key in string]?: unknown;
+    };
+    filePath: string;
+};
+export declare function getPackageJson(startPath?: string): PackageJson | null;
+export {};

node_modules/eslint-plugin-svelte/lib/utils/get-package-json.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageJson = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cache_1 = require("./cache");
+const isRunOnBrowser = !fs_1.default.readFileSync;
+const cache = (0, cache_1.createCache)();
+function readPackageJson(dir) {
+    if (isRunOnBrowser)
+        return null;
+    const filePath = path_1.default.join(dir, 'package.json');
+    try {
+        const text = fs_1.default.readFileSync(filePath, 'utf8');
+        const data = JSON.parse(text);
+        if (typeof data === 'object' && data !== null) {
+            data.filePath = filePath;
+            return data;
+        }
+    }
+    catch (_err) {
+    }
+    return null;
+}
+function getPackageJson(startPath = 'a.js') {
+    if (isRunOnBrowser)
+        return null;
+    const startDir = path_1.default.dirname(path_1.default.resolve(startPath));
+    let dir = startDir;
+    let prevDir = '';
+    let data = null;
+    do {
+        data = cache.get(dir);
+        if (data) {
+            if (dir !== startDir) {
+                cache.set(startDir, data);
+            }
+            return data;
+        }
+        data = readPackageJson(dir);
+        if (data) {
+            cache.set(dir, data);
+            cache.set(startDir, data);
+            return data;
+        }
+        prevDir = dir;
+        dir = path_1.default.resolve(dir, '..');
+    } while (dir !== prevDir);
+    cache.set(startDir, null);
+    return null;
+}
+exports.getPackageJson = getPackageJson;

node_modules/eslint-plugin-svelte/lib/utils/index.d.ts

@@ -0,0 +1,2 @@
+import type { RuleModule, PartialRuleModule } from '../types';
+export declare function createRule(ruleName: string, rule: PartialRuleModule): RuleModule;

node_modules/eslint-plugin-svelte/lib/utils/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRule = void 0;
+function createRule(ruleName, rule) {
+    return {
+        meta: {
+            ...rule.meta,
+            docs: {
+                ...rule.meta.docs,
+                url: `https://sveltejs.github.io/eslint-plugin-svelte/rules/${ruleName}/`,
+                ruleId: `svelte/${ruleName}`,
+                ruleName
+            }
+        },
+        create: rule.create
+    };
+}
+exports.createRule = createRule;

node_modules/eslint-plugin-svelte/lib/utils/lines-and-columns.d.ts

@@ -0,0 +1,12 @@
+export declare class LinesAndColumns {
+    private readonly lineStartIndices;
+    constructor(code: string);
+    getLocFromIndex(index: number): {
+        line: number;
+        column: number;
+    };
+    getIndexFromLoc(loc: {
+        line: number;
+        column: number;
+    }): number;
+}

node_modules/eslint-plugin-svelte/lib/utils/lines-and-columns.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinesAndColumns = void 0;
+class LinesAndColumns {
+    constructor(code) {
+        const len = code.length;
+        const lineStartIndices = [0];
+        for (let index = 0; index < len; index++) {
+            const c = code[index];
+            if (c === '\r') {
+                const next = code[index + 1] || '';
+                if (next === '\n') {
+                    index++;
+                }
+                lineStartIndices.push(index + 1);
+            }
+            else if (c === '\n') {
+                lineStartIndices.push(index + 1);
+            }
+        }
+        this.lineStartIndices = lineStartIndices;
+    }
+    getLocFromIndex(index) {
+        const lineNumber = sortedLastIndex(this.lineStartIndices, index);
+        return {
+            line: lineNumber,
+            column: index - this.lineStartIndices[lineNumber - 1]
+        };
+    }
+    getIndexFromLoc(loc) {
+        const lineStartIndex = this.lineStartIndices[loc.line - 1];
+        const positionIndex = lineStartIndex + loc.column;
+        return positionIndex;
+    }
+}
+exports.LinesAndColumns = LinesAndColumns;
+function sortedLastIndex(array, value) {
+    let lower = 0;
+    let upper = array.length;
+    while (lower < upper) {
+        const mid = Math.floor(lower + (upper - lower) / 2);
+        const target = array[mid];
+        if (target < value) {
+            lower = mid + 1;
+        }
+        else if (target > value) {
+            upper = mid;
+        }
+        else {
+            return mid + 1;
+        }
+    }
+    return upper;
+}

node_modules/eslint-plugin-svelte/lib/utils/load-module.d.ts

@@ -0,0 +1,3 @@
+import type { RuleContext } from '../types';
+export declare function loadModule<R>(context: RuleContext, name: string): R | null;
+export declare function loadModulesForBrowser(): Promise<void>;

node_modules/eslint-plugin-svelte/lib/utils/load-module.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModulesForBrowser = exports.loadModule = void 0;
+const module_1 = __importDefault(require("module"));
+const path_1 = __importDefault(require("path"));
+const compat_1 = require("./compat");
+const cache = new WeakMap();
+const cache4b = new Map();
+function loadModule(context, name) {
+    const key = (0, compat_1.getSourceCode)(context).ast;
+    let modules = cache.get(key);
+    if (!modules) {
+        modules = {};
+        cache.set(key, modules);
+    }
+    const mod = modules[name] || cache4b.get(name);
+    if (mod)
+        return mod;
+    try {
+        const cwd = (0, compat_1.getCwd)(context);
+        const relativeTo = path_1.default.join(cwd, '__placeholder__.js');
+        return (modules[name] = module_1.default.createRequire(relativeTo)(name));
+    }
+    catch {
+    }
+    for (const relativeTo of [
+        (0, compat_1.getFilename)(context),
+        (0, compat_1.getPhysicalFilename)(context),
+        typeof __filename !== 'undefined' ? __filename : ''
+    ]) {
+        if (relativeTo) {
+            try {
+                return (modules[name] = module_1.default.createRequire(relativeTo)(name));
+            }
+            catch {
+            }
+        }
+    }
+    return null;
+}
+exports.loadModule = loadModule;
+async function loadModulesForBrowser() {
+    const [sass, typescript] = await Promise.all([import('sass'), import('typescript')]);
+    cache4b.set('sass', sass);
+    cache4b.set('typescript', typescript);
+}
+exports.loadModulesForBrowser = loadModulesForBrowser;

node_modules/eslint-plugin-svelte/lib/utils/regexp.d.ts

@@ -0,0 +1,4 @@
+export declare function toRegExp(string: string): {
+    test(s: string): boolean;
+};
+export declare function isRegExp(string: string): boolean;

node_modules/eslint-plugin-svelte/lib/utils/regexp.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRegExp = exports.toRegExp = void 0;
+const RE_REGEXP_STR = /^\/(.+)\/([A-Za-z]*)$/u;
+function toRegExp(string) {
+    const parts = RE_REGEXP_STR.exec(string);
+    if (parts) {
+        return new RegExp(parts[1], parts[2]);
+    }
+    return { test: (s) => s === string };
+}
+exports.toRegExp = toRegExp;
+function isRegExp(string) {
+    return Boolean(RE_REGEXP_STR.test(string));
+}
+exports.isRegExp = isRegExp;

node_modules/eslint-plugin-svelte/lib/utils/rules.d.ts

@@ -0,0 +1,2 @@
+import type { RuleModule } from '../types';
+export declare const rules: RuleModule[];

node_modules/eslint-plugin-svelte/lib/utils/rules.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rules = void 0;
+const no_unnecessary_condition_1 = __importDefault(require("../rules/@typescript-eslint/no-unnecessary-condition"));
+const block_lang_1 = __importDefault(require("../rules/block-lang"));
+const button_has_type_1 = __importDefault(require("../rules/button-has-type"));
+const comment_directive_1 = __importDefault(require("../rules/comment-directive"));
+const derived_has_same_inputs_outputs_1 = __importDefault(require("../rules/derived-has-same-inputs-outputs"));
+const experimental_require_slot_types_1 = __importDefault(require("../rules/experimental-require-slot-types"));
+const experimental_require_strict_events_1 = __importDefault(require("../rules/experimental-require-strict-events"));
+const first_attribute_linebreak_1 = __importDefault(require("../rules/first-attribute-linebreak"));
+const html_closing_bracket_spacing_1 = __importDefault(require("../rules/html-closing-bracket-spacing"));
+const html_quotes_1 = __importDefault(require("../rules/html-quotes"));
+const html_self_closing_1 = __importDefault(require("../rules/html-self-closing"));
+const indent_1 = __importDefault(require("../rules/indent"));
+const infinite_reactive_loop_1 = __importDefault(require("../rules/infinite-reactive-loop"));
+const max_attributes_per_line_1 = __importDefault(require("../rules/max-attributes-per-line"));
+const mustache_spacing_1 = __importDefault(require("../rules/mustache-spacing"));
+const no_at_debug_tags_1 = __importDefault(require("../rules/no-at-debug-tags"));
+const no_at_html_tags_1 = __importDefault(require("../rules/no-at-html-tags"));
+const no_dom_manipulating_1 = __importDefault(require("../rules/no-dom-manipulating"));
+const no_dupe_else_if_blocks_1 = __importDefault(require("../rules/no-dupe-else-if-blocks"));
+const no_dupe_on_directives_1 = __importDefault(require("../rules/no-dupe-on-directives"));
+const no_dupe_style_properties_1 = __importDefault(require("../rules/no-dupe-style-properties"));
+const no_dupe_use_directives_1 = __importDefault(require("../rules/no-dupe-use-directives"));
+const no_dynamic_slot_name_1 = __importDefault(require("../rules/no-dynamic-slot-name"));
+const no_export_load_in_svelte_module_in_kit_pages_1 = __importDefault(require("../rules/no-export-load-in-svelte-module-in-kit-pages"));
+const no_extra_reactive_curlies_1 = __importDefault(require("../rules/no-extra-reactive-curlies"));
+const no_ignored_unsubscribe_1 = __importDefault(require("../rules/no-ignored-unsubscribe"));
+const no_immutable_reactive_statements_1 = __importDefault(require("../rules/no-immutable-reactive-statements"));
+const no_inline_styles_1 = __importDefault(require("../rules/no-inline-styles"));
+const no_inner_declarations_1 = __importDefault(require("../rules/no-inner-declarations"));
+const no_not_function_handler_1 = __importDefault(require("../rules/no-not-function-handler"));
+const no_object_in_text_mustaches_1 = __importDefault(require("../rules/no-object-in-text-mustaches"));
+const no_reactive_functions_1 = __importDefault(require("../rules/no-reactive-functions"));
+const no_reactive_literals_1 = __importDefault(require("../rules/no-reactive-literals"));
+const no_reactive_reassign_1 = __importDefault(require("../rules/no-reactive-reassign"));
+const no_restricted_html_elements_1 = __importDefault(require("../rules/no-restricted-html-elements"));
+const no_shorthand_style_property_overrides_1 = __importDefault(require("../rules/no-shorthand-style-property-overrides"));
+const no_spaces_around_equal_signs_in_attribute_1 = __importDefault(require("../rules/no-spaces-around-equal-signs-in-attribute"));
+const no_store_async_1 = __importDefault(require("../rules/no-store-async"));
+const no_target_blank_1 = __importDefault(require("../rules/no-target-blank"));
+const no_trailing_spaces_1 = __importDefault(require("../rules/no-trailing-spaces"));
+const no_unknown_style_directive_property_1 = __importDefault(require("../rules/no-unknown-style-directive-property"));
+const no_unused_class_name_1 = __importDefault(require("../rules/no-unused-class-name"));
+const no_unused_svelte_ignore_1 = __importDefault(require("../rules/no-unused-svelte-ignore"));
+const no_useless_mustaches_1 = __importDefault(require("../rules/no-useless-mustaches"));
+const prefer_class_directive_1 = __importDefault(require("../rules/prefer-class-directive"));
+const prefer_destructured_store_props_1 = __importDefault(require("../rules/prefer-destructured-store-props"));
+const prefer_style_directive_1 = __importDefault(require("../rules/prefer-style-directive"));
+const require_each_key_1 = __importDefault(require("../rules/require-each-key"));
+const require_event_dispatcher_types_1 = __importDefault(require("../rules/require-event-dispatcher-types"));
+const require_optimized_style_attribute_1 = __importDefault(require("../rules/require-optimized-style-attribute"));
+const require_store_callbacks_use_set_param_1 = __importDefault(require("../rules/require-store-callbacks-use-set-param"));
+const require_store_reactive_access_1 = __importDefault(require("../rules/require-store-reactive-access"));
+const require_stores_init_1 = __importDefault(require("../rules/require-stores-init"));
+const shorthand_attribute_1 = __importDefault(require("../rules/shorthand-attribute"));
+const shorthand_directive_1 = __importDefault(require("../rules/shorthand-directive"));
+const sort_attributes_1 = __importDefault(require("../rules/sort-attributes"));
+const spaced_html_comment_1 = __importDefault(require("../rules/spaced-html-comment"));
+const system_1 = __importDefault(require("../rules/system"));
+const valid_compile_1 = __importDefault(require("../rules/valid-compile"));
+const valid_each_key_1 = __importDefault(require("../rules/valid-each-key"));
+const valid_prop_names_in_kit_pages_1 = __importDefault(require("../rules/valid-prop-names-in-kit-pages"));
+exports.rules = [
+    no_unnecessary_condition_1.default,
+    block_lang_1.default,
+    button_has_type_1.default,
+    comment_directive_1.default,
+    derived_has_same_inputs_outputs_1.default,
+    experimental_require_slot_types_1.default,
+    experimental_require_strict_events_1.default,
+    first_attribute_linebreak_1.default,
+    html_closing_bracket_spacing_1.default,
+    html_quotes_1.default,
+    html_self_closing_1.default,
+    indent_1.default,
+    infinite_reactive_loop_1.default,
+    max_attributes_per_line_1.default,
+    mustache_spacing_1.default,
+    no_at_debug_tags_1.default,
+    no_at_html_tags_1.default,
+    no_dom_manipulating_1.default,
+    no_dupe_else_if_blocks_1.default,
+    no_dupe_on_directives_1.default,
+    no_dupe_style_properties_1.default,
+    no_dupe_use_directives_1.default,
+    no_dynamic_slot_name_1.default,
+    no_export_load_in_svelte_module_in_kit_pages_1.default,
+    no_extra_reactive_curlies_1.default,
+    no_ignored_unsubscribe_1.default,
+    no_immutable_reactive_statements_1.default,
+    no_inline_styles_1.default,
+    no_inner_declarations_1.default,
+    no_not_function_handler_1.default,
+    no_object_in_text_mustaches_1.default,
+    no_reactive_functions_1.default,
+    no_reactive_literals_1.default,
+    no_reactive_reassign_1.default,
+    no_restricted_html_elements_1.default,
+    no_shorthand_style_property_overrides_1.default,
+    no_spaces_around_equal_signs_in_attribute_1.default,
+    no_store_async_1.default,
+    no_target_blank_1.default,
+    no_trailing_spaces_1.default,
+    no_unknown_style_directive_property_1.default,
+    no_unused_class_name_1.default,
+    no_unused_svelte_ignore_1.default,
+    no_useless_mustaches_1.default,
+    prefer_class_directive_1.default,
+    prefer_destructured_store_props_1.default,
+    prefer_style_directive_1.default,
+    require_each_key_1.default,
+    require_event_dispatcher_types_1.default,
+    require_optimized_style_attribute_1.default,
+    require_store_callbacks_use_set_param_1.default,
+    require_store_reactive_access_1.default,
+    require_stores_init_1.default,
+    shorthand_attribute_1.default,
+    shorthand_directive_1.default,
+    sort_attributes_1.default,
+    spaced_html_comment_1.default,
+    system_1.default,
+    valid_compile_1.default,
+    valid_each_key_1.default,
+    valid_prop_names_in_kit_pages_1.default
+];

node_modules/eslint-plugin-svelte/lib/utils/svelte-kit.d.ts

@@ -0,0 +1,2 @@
+import type { RuleContext } from '../types';
+export declare function isKitPageComponent(context: RuleContext): boolean;

node_modules/eslint-plugin-svelte/lib/utils/svelte-kit.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKitPageComponent = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const get_package_json_1 = require("./get-package-json");
+const compat_1 = require("./compat");
+const isRunOnBrowser = !fs_1.default.readFileSync;
+function isKitPageComponent(context) {
+    if (isRunOnBrowser)
+        return true;
+    if (!hasSvelteKit((0, compat_1.getFilename)(context)))
+        return false;
+    const routes = context.settings?.svelte?.kit?.files?.routes?.replace(/^\//, '') ?? 'src/routes';
+    const filePath = (0, compat_1.getFilename)(context);
+    const projectRootDir = getProjectRootDir((0, compat_1.getFilename)(context)) ?? '';
+    const fileName = path_1.default.basename(filePath);
+    return (filePath.startsWith(path_1.default.join(projectRootDir, routes)) &&
+        Boolean(/^\+.+\.svelte$/.test(fileName)));
+}
+exports.isKitPageComponent = isKitPageComponent;
+function hasSvelteKit(filePath) {
+    if (isRunOnBrowser)
+        return true;
+    try {
+        const packageJson = (0, get_package_json_1.getPackageJson)(filePath);
+        if (!packageJson)
+            return false;
+        if (packageJson.name === 'eslint-plugin-svelte')
+            return true;
+        return Boolean(packageJson.dependencies?.['@sveltejs/kit'] ?? packageJson.devDependencies?.['@sveltejs/kit']);
+    }
+    catch (_e) {
+        return false;
+    }
+}
+function getProjectRootDir(filePath) {
+    if (isRunOnBrowser)
+        return null;
+    const packageJsonFilePath = (0, get_package_json_1.getPackageJson)(filePath)?.filePath;
+    if (!packageJsonFilePath)
+        return null;
+    return path_1.default.dirname(path_1.default.resolve(packageJsonFilePath));
+}

node_modules/eslint-plugin-svelte/lib/utils/ts-utils/index.d.ts

@@ -0,0 +1,35 @@
+import type { RuleContext, ASTNode } from '../../types';
+import type * as TS from 'typescript';
+export type TypeScript = typeof TS;
+export type { TS };
+export type TSTools = {
+    service: {
+        esTreeNodeToTSNodeMap: ReadonlyMap<unknown, TS.Node>;
+        tsNodeToESTreeNodeMap: ReadonlyMap<TS.Node, ASTNode>;
+        program: TS.Program;
+        hasFullTypeInformation: boolean;
+    };
+    ts: TypeScript;
+};
+export declare function getTypeScriptTools(context: RuleContext): TSTools | null;
+export declare function getTypeScript(context: RuleContext): TypeScript | null;
+export declare function isTruthyLiteral(type: TS.Type, tsTools: TSTools): boolean;
+export declare function isFalsyType(type: TS.Type, tsTools: TSTools): boolean;
+export declare function isNullishType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isNullableType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isBooleanLiteralType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isObjectType(type: TS.Type, ts: TypeScript): type is TS.ObjectType;
+export declare function isReferenceObjectType(type: TS.Type, ts: TypeScript): type is TS.TypeReference;
+export declare function isTupleObjectType(type: TS.Type, ts: TypeScript): type is TS.TupleType;
+export declare function isTupleType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isAnyType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isUnknownType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isNeverType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isUndefinedType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isVoidType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isNullType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isPossiblyFalsyType(type: TS.Type, ts: TypeScript): boolean;
+export declare function getCallSignaturesOfType(type: TS.Type): readonly TS.Signature[];
+export declare function getConstrainedTypeAtLocation(checker: TS.TypeChecker, node: TS.Node): TS.Type;
+export declare function getTypeName(type: TS.Type, tsTools: TSTools): string;
+export declare function getTypeOfPropertyOfType(type: TS.Type, name: string, checker: TS.TypeChecker): TS.Type | undefined;

node_modules/eslint-plugin-svelte/lib/utils/ts-utils/index.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeOfPropertyOfType = exports.getTypeName = exports.getConstrainedTypeAtLocation = exports.getCallSignaturesOfType = exports.isPossiblyFalsyType = exports.isNullType = exports.isVoidType = exports.isUndefinedType = exports.isNeverType = exports.isUnknownType = exports.isAnyType = exports.isTupleType = exports.isTupleObjectType = exports.isReferenceObjectType = exports.isObjectType = exports.isBooleanLiteralType = exports.isNullableType = exports.isNullishType = exports.isFalsyType = exports.isTruthyLiteral = exports.getTypeScript = exports.getTypeScriptTools = void 0;
+const load_module_1 = require("../load-module");
+const compat_1 = require("../compat");
+function getTypeScriptTools(context) {
+    const ts = getTypeScript(context);
+    if (!ts) {
+        return null;
+    }
+    const sourceCode = (0, compat_1.getSourceCode)(context);
+    const { program, esTreeNodeToTSNodeMap, tsNodeToESTreeNodeMap } = sourceCode.parserServices;
+    if (!program || !esTreeNodeToTSNodeMap || !tsNodeToESTreeNodeMap) {
+        return null;
+    }
+    const hasFullTypeInformation = sourceCode.parserServices.hasFullTypeInformation ?? true;
+    if (!hasFullTypeInformation) {
+        return null;
+    }
+    return {
+        service: {
+            esTreeNodeToTSNodeMap,
+            tsNodeToESTreeNodeMap,
+            hasFullTypeInformation,
+            program
+        },
+        ts
+    };
+}
+exports.getTypeScriptTools = getTypeScriptTools;
+let cacheTypeScript = null;
+function getTypeScript(context) {
+    if (cacheTypeScript) {
+        return cacheTypeScript;
+    }
+    cacheTypeScript = (0, load_module_1.loadModule)(context, 'typescript');
+    if (cacheTypeScript) {
+        return cacheTypeScript;
+    }
+    try {
+        cacheTypeScript ?? (cacheTypeScript = require('typescript'));
+    }
+    catch {
+    }
+    return cacheTypeScript;
+}
+exports.getTypeScript = getTypeScript;
+function isTruthyLiteral(type, tsTools) {
+    if (type.isUnion()) {
+        return type.types.every((t) => isTruthyLiteral(t, tsTools));
+    }
+    return ((isBooleanLiteralType(type, tsTools.ts) &&
+        tsTools.service.program.getTypeChecker().typeToString(type) === 'true') ||
+        (type.isLiteral() && Boolean(type.value)));
+}
+exports.isTruthyLiteral = isTruthyLiteral;
+function isFalsyType(type, tsTools) {
+    if (type.isUnion()) {
+        return type.types.every((t) => isFalsyType(t, tsTools));
+    }
+    if (isUndefinedType(type, tsTools.ts) ||
+        isNullType(type, tsTools.ts) ||
+        isVoidType(type, tsTools.ts))
+        return true;
+    if (type.isLiteral())
+        return !type.value;
+    return (isBooleanLiteralType(type, tsTools.ts) &&
+        tsTools.service.program.getTypeChecker().typeToString(type) === 'false');
+}
+exports.isFalsyType = isFalsyType;
+function isNullishType(type, ts) {
+    if (type.isUnion()) {
+        return type.types.every((t) => isNullishType(t, ts));
+    }
+    return isNullType(type, ts) || isUndefinedType(type, ts);
+}
+exports.isNullishType = isNullishType;
+function isNullableType(type, ts) {
+    if (type.isUnion()) {
+        return type.types.some((t) => isNullableType(t, ts));
+    }
+    return isNullType(type, ts) || isUndefinedType(type, ts);
+}
+exports.isNullableType = isNullableType;
+function isBooleanLiteralType(type, ts) {
+    return (type.flags & ts.TypeFlags.BooleanLiteral) !== 0;
+}
+exports.isBooleanLiteralType = isBooleanLiteralType;
+function isObjectType(type, ts) {
+    return (type.flags & ts.TypeFlags.Object) !== 0;
+}
+exports.isObjectType = isObjectType;
+function isReferenceObjectType(type, ts) {
+    return isObjectType(type, ts) && (type.objectFlags & ts.ObjectFlags.Reference) !== 0;
+}
+exports.isReferenceObjectType = isReferenceObjectType;
+function isTupleObjectType(type, ts) {
+    return isObjectType(type, ts) && (type.objectFlags & ts.ObjectFlags.Tuple) !== 0;
+}
+exports.isTupleObjectType = isTupleObjectType;
+function isTupleType(type, ts) {
+    return (isTupleObjectType(type, ts) ||
+        (isReferenceObjectType(type, ts) && isTupleObjectType(type.target, ts)));
+}
+exports.isTupleType = isTupleType;
+function isAnyType(type, ts) {
+    return (type.flags & ts.TypeFlags.Any) !== 0;
+}
+exports.isAnyType = isAnyType;
+function isUnknownType(type, ts) {
+    return (type.flags & ts.TypeFlags.Unknown) !== 0;
+}
+exports.isUnknownType = isUnknownType;
+function isNeverType(type, ts) {
+    return (type.flags & ts.TypeFlags.Never) !== 0;
+}
+exports.isNeverType = isNeverType;
+function isUndefinedType(type, ts) {
+    return (type.flags & ts.TypeFlags.Undefined) !== 0;
+}
+exports.isUndefinedType = isUndefinedType;
+function isVoidType(type, ts) {
+    return (type.flags & ts.TypeFlags.Void) !== 0;
+}
+exports.isVoidType = isVoidType;
+function isNullType(type, ts) {
+    return (type.flags & ts.TypeFlags.Null) !== 0;
+}
+exports.isNullType = isNullType;
+function isPossiblyFalsyType(type, ts) {
+    if (type.isUnion()) {
+        return type.types.some((t) => isPossiblyFalsyType(t, ts));
+    }
+    return (type.flags & ts.TypeFlags.PossiblyFalsy) !== 0;
+}
+exports.isPossiblyFalsyType = isPossiblyFalsyType;
+function getCallSignaturesOfType(type) {
+    if (type.isUnion()) {
+        return type.types.flatMap((t) => getCallSignaturesOfType(t));
+    }
+    if (type.isIntersection()) {
+        let signatures = [];
+        for (const t of type.types) {
+            const sig = getCallSignaturesOfType(t);
+            if (sig.length !== 0) {
+                if (signatures.length) {
+                    return [];
+                }
+                signatures = sig;
+            }
+        }
+        return signatures;
+    }
+    return type.getCallSignatures();
+}
+exports.getCallSignaturesOfType = getCallSignaturesOfType;
+function getConstrainedTypeAtLocation(checker, node) {
+    const nodeType = checker.getTypeAtLocation(node);
+    const constrained = checker.getBaseConstraintOfType(nodeType);
+    return constrained ?? nodeType;
+}
+exports.getConstrainedTypeAtLocation = getConstrainedTypeAtLocation;
+function getTypeName(type, tsTools) {
+    const { ts } = tsTools;
+    if ((type.flags & ts.TypeFlags.StringLike) !== 0) {
+        return 'string';
+    }
+    const typeChecker = tsTools.service.program.getTypeChecker();
+    if ((type.flags & ts.TypeFlags.TypeParameter) !== 0) {
+        const symbol = type.getSymbol();
+        const decls = symbol?.getDeclarations();
+        const typeParamDecl = decls?.[0];
+        if (ts.isTypeParameterDeclaration(typeParamDecl) && typeParamDecl.constraint != null) {
+            return getTypeName(typeChecker.getTypeFromTypeNode(typeParamDecl.constraint), tsTools);
+        }
+    }
+    if (type.isUnion() &&
+        type.types.map((value) => getTypeName(value, tsTools)).every((t) => t === 'string')) {
+        return 'string';
+    }
+    if (type.isIntersection() &&
+        type.types.map((value) => getTypeName(value, tsTools)).some((t) => t === 'string')) {
+        return 'string';
+    }
+    return typeChecker.typeToString(type);
+}
+exports.getTypeName = getTypeName;
+function getTypeOfPropertyOfType(type, name, checker) {
+    return checker.getTypeOfPropertyOfType(type, name);
+}
+exports.getTypeOfPropertyOfType = getTypeOfPropertyOfType;

node_modules/eslint-plugin-svelte/lib/utils/void-elements.d.ts

@@ -0,0 +1,2 @@
+declare const voidElements: string[];
+export default voidElements;

node_modules/eslint-plugin-svelte/lib/utils/void-elements.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const voidElements = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'keygen',
+    'link',
+    'menuitem',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr'
+];
+exports.default = voidElements;