ash/printer-notifications
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat: docker compose maybe

Browse Source
This commit is contained in:
Ashley Flanagan
2023-11-13 16:10:04 -05:00
parent 180b261e40
commit b625ccd8d6
8031 changed files with 2182966 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
node_modules/eslint-plugin-svelte/lib/utils/ast-utils.d.ts generated vendored Normal file
View File

@ -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;

430
node_modules/eslint-plugin-svelte/lib/utils/ast-utils.js generated vendored Normal file
View File

@ -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);
}

4
node_modules/eslint-plugin-svelte/lib/utils/cache.d.ts generated vendored Normal file
View File

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

32
node_modules/eslint-plugin-svelte/lib/utils/cache.js generated vendored Normal file
View File

@ -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;

5
node_modules/eslint-plugin-svelte/lib/utils/compat.d.ts generated vendored Normal file
View File

@ -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;

20
node_modules/eslint-plugin-svelte/lib/utils/compat.js generated vendored Normal file
View File

@ -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;

3
node_modules/eslint-plugin-svelte/lib/utils/css-utils/index.d.ts generated vendored Normal file
View File

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

19
node_modules/eslint-plugin-svelte/lib/utils/css-utils/index.js generated vendored Normal file
View File

@ -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);

1
node_modules/eslint-plugin-svelte/lib/utils/css-utils/resource.d.ts generated vendored Normal file
View File

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

156
node_modules/eslint-plugin-svelte/lib/utils/css-utils/resource.js generated vendored Normal file
View File

@ -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'
]
]
]);

43
node_modules/eslint-plugin-svelte/lib/utils/css-utils/style-attribute.d.ts generated vendored Normal file
View File

@ -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;

261
node_modules/eslint-plugin-svelte/lib/utils/css-utils/style-attribute.js generated vendored Normal file
View File

@ -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])
};
}

5
node_modules/eslint-plugin-svelte/lib/utils/css-utils/template-safe-parser.d.ts generated vendored Normal file
View File

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

13
node_modules/eslint-plugin-svelte/lib/utils/css-utils/template-safe-parser.js generated vendored Normal file
View File

@ -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;

5
node_modules/eslint-plugin-svelte/lib/utils/css-utils/template-tokenize.d.ts generated vendored Normal file
View File

@ -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;

39
node_modules/eslint-plugin-svelte/lib/utils/css-utils/template-tokenize.js generated vendored Normal file
View File

@ -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;

3
node_modules/eslint-plugin-svelte/lib/utils/css-utils/utils.d.ts generated vendored Normal file
View File

@ -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;

15
node_modules/eslint-plugin-svelte/lib/utils/css-utils/utils.js generated vendored Normal file
View File

@ -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;

13
node_modules/eslint-plugin-svelte/lib/utils/eslint-core.d.ts generated vendored Normal file
View File

@ -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;

55
node_modules/eslint-plugin-svelte/lib/utils/eslint-core.js generated vendored Normal file
View File

@ -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;

12
node_modules/eslint-plugin-svelte/lib/utils/get-package-json.d.ts generated vendored Normal file
View File

@ -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 {};

55
node_modules/eslint-plugin-svelte/lib/utils/get-package-json.js generated vendored Normal file
View File

@ -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;

2
node_modules/eslint-plugin-svelte/lib/utils/index.d.ts generated vendored Normal file
View File

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

18
node_modules/eslint-plugin-svelte/lib/utils/index.js generated vendored Normal file
View File

@ -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;

12
node_modules/eslint-plugin-svelte/lib/utils/lines-and-columns.d.ts generated vendored Normal file
View File

@ -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;
}

54
node_modules/eslint-plugin-svelte/lib/utils/lines-and-columns.js generated vendored Normal file
View File

@ -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;
}

3
node_modules/eslint-plugin-svelte/lib/utils/load-module.d.ts generated vendored Normal file
View File

@ -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>;

50
node_modules/eslint-plugin-svelte/lib/utils/load-module.js generated vendored Normal file
View File

@ -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;

4
node_modules/eslint-plugin-svelte/lib/utils/regexp.d.ts generated vendored Normal file
View File

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

16
node_modules/eslint-plugin-svelte/lib/utils/regexp.js generated vendored Normal file
View File

@ -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;

2
node_modules/eslint-plugin-svelte/lib/utils/rules.d.ts generated vendored Normal file
View File

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

130
node_modules/eslint-plugin-svelte/lib/utils/rules.js generated vendored Normal file
View File

@ -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
];

2
node_modules/eslint-plugin-svelte/lib/utils/svelte-kit.d.ts generated vendored Normal file
View File

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

47
node_modules/eslint-plugin-svelte/lib/utils/svelte-kit.js generated vendored Normal file
View File

@ -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));
}

35
node_modules/eslint-plugin-svelte/lib/utils/ts-utils/index.d.ts generated vendored Normal file
View File

@ -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;

191
node_modules/eslint-plugin-svelte/lib/utils/ts-utils/index.js generated vendored Normal file
View File

@ -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;

2
node_modules/eslint-plugin-svelte/lib/utils/void-elements.d.ts generated vendored Normal file
View File

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

21
node_modules/eslint-plugin-svelte/lib/utils/void-elements.js generated vendored Normal file
View File

@ -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;