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

114
node_modules/svelte-eslint-parser/lib/context/index.d.ts generated vendored Normal file
View File

@ -0,0 +1,114 @@
import type { Comment, Locations, SvelteElement, SvelteHTMLElement, SvelteScriptElement, SvelteStyleElement, Token } from "../ast";
import type ESTree from "estree";
import type * as SvAST from "../parser/svelte-ast-types";
import { ScriptLetContext } from "./script-let";
import { LetDirectiveCollections } from "./let-directive-collection";
import type { AttributeToken } from "../parser/html";
export declare class ScriptsSourceCode {
private raw;
private trimmedRaw;
readonly attrs: Record<string, string | undefined>;
private _separate;
private _appendScriptLets;
separateIndexes: number[];
constructor(script: string, attrs: Record<string, string | undefined>);
getCurrentVirtualCode(): string;
getCurrentVirtualCodeInfo(): {
script: string;
render: string;
};
getCurrentVirtualCodeLength(): number;
addLet(letCode: string): {
start: number;
end: number;
};
stripCode(start: number, end: number): void;
}
export type ContextSourceCode = {
template: string;
scripts: ScriptsSourceCode;
};
export declare class Context {
readonly code: string;
readonly parserOptions: any;
readonly sourceCode: ContextSourceCode;
readonly tokens: Token[];
readonly comments: Comment[];
private readonly locs;
private readonly locsMap;
readonly scriptLet: ScriptLetContext;
readonly letDirCollections: LetDirectiveCollections;
readonly slots: Set<SvelteHTMLElement>;
readonly elements: Map<SvelteElement, SvAST.Element | SvAST.InlineComponent | SvAST.Window | SvAST.Document | SvAST.Body | SvAST.Head | SvAST.Title | SvAST.Options | SvAST.SlotTemplate | SvAST.Slot>;
private readonly state;
private readonly blocks;
constructor(code: string, parserOptions: any);
getLocFromIndex(index: number): {
line: number;
column: number;
};
getIndexFromLoc(loc: {
line: number;
column: number;
}): number;
/**
* Get the location information of the given node.
* @param node The node.
*/
getConvertLocation(node: {
start: number;
end: number;
} | ESTree.Node): Locations;
addComment(comment: Comment): void;
/**
* Add token to tokens
*/
addToken(type: Token["type"], range: {
start: number;
end: number;
}): Token;
/**
* get text
*/
getText(range: {
start: number;
end: number;
} | ESTree.Node): string;
isTypeScript(): boolean;
stripScriptCode(start: number, end: number): void;
findBlock(element: SvelteScriptElement | SvelteStyleElement | SvelteElement): Block | undefined;
findSelfClosingBlock(element: SvelteElement): SelfClosingBlock | undefined;
}
type Block = {
tag: "script" | "style" | "template";
originalTag: string;
attrs: AttributeToken[];
selfClosing?: false;
contentRange: [number, number];
startTagRange: [number, number];
endTagRange: [number, number];
} | SelfClosingBlock;
type SelfClosingBlock = {
tag: "script" | "style" | "template";
originalTag: string;
attrs: AttributeToken[];
selfClosing: true;
startTagRange: [number, number];
};
export declare class LinesAndColumns {
private readonly lineStartIndices;
constructor(code: string);
getLocFromIndex(index: number): {
line: number;
column: number;
};
getIndexFromLoc(loc: {
line: number;
column: number;
}): number;
/**
* Get the location information of the given indexes.
*/
getLocations(start: number, end: number): Locations;
}
export {};

354
node_modules/svelte-eslint-parser/lib/context/index.js generated vendored Normal file
View File

@ -0,0 +1,354 @@
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.LinesAndColumns = exports.Context = exports.ScriptsSourceCode = void 0;
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const script_let_1 = require("./script-let");
const let_directive_collection_1 = require("./let-directive-collection");
const resolve_parser_1 = require("../parser/resolve-parser");
const html_1 = require("../parser/html");
const parser_object_1 = require("../parser/parser-object");
const utils_1 = require("../utils");
const TS_PARSER_NAMES = [
"@typescript-eslint/parser",
"typescript-eslint-parser-for-extra-files",
];
class ScriptsSourceCode {
constructor(script, attrs) {
this._separate = "";
this._appendScriptLets = null;
this.separateIndexes = [];
this.raw = script;
this.trimmedRaw = script.trimEnd();
this.attrs = attrs;
this.separateIndexes = [script.length];
}
getCurrentVirtualCode() {
if (this._appendScriptLets == null) {
return this.raw;
}
return this.trimmedRaw + this._separate + this._appendScriptLets;
}
getCurrentVirtualCodeInfo() {
if (this._appendScriptLets == null) {
return { script: this.raw, render: "" };
}
return {
script: this.trimmedRaw + this._separate,
render: this._appendScriptLets,
};
}
getCurrentVirtualCodeLength() {
if (this._appendScriptLets == null) {
return this.raw.length;
}
return (this.trimmedRaw.length +
this._separate.length +
this._appendScriptLets.length);
}
addLet(letCode) {
if (this._appendScriptLets == null) {
this._appendScriptLets = "";
const currentLength = this.getCurrentVirtualCodeLength();
this.separateIndexes = [currentLength, currentLength + 1];
this._separate += "\n;";
const after = this.raw.slice(this.getCurrentVirtualCodeLength());
this._appendScriptLets += after;
}
const start = this.getCurrentVirtualCodeLength();
this._appendScriptLets += letCode;
return {
start,
end: this.getCurrentVirtualCodeLength(),
};
}
stripCode(start, end) {
this.raw =
this.raw.slice(0, start) +
this.raw.slice(start, end).replace(/[^\n\r ]/g, " ") +
this.raw.slice(end);
this.trimmedRaw =
this.trimmedRaw.slice(0, start) +
this.trimmedRaw.slice(start, end).replace(/[^\n\r ]/g, " ") +
this.trimmedRaw.slice(end);
}
}
exports.ScriptsSourceCode = ScriptsSourceCode;
class Context {
constructor(code, parserOptions) {
var _a;
this.tokens = [];
this.comments = [];
this.locsMap = new Map();
this.letDirCollections = new let_directive_collection_1.LetDirectiveCollections();
this.slots = new Set();
this.elements = new Map();
// ----- States ------
this.state = {};
this.blocks = [];
this.code = code;
this.parserOptions = parserOptions;
this.locs = new LinesAndColumns(code);
const spaces = code.replace(/[^\n\r ]/g, " ");
let templateCode = "";
let scriptCode = "";
const scriptAttrs = {};
let start = 0;
for (const block of extractBlocks(code)) {
if (block.tag === "template") {
if (block.selfClosing) {
continue;
}
const lang = block.attrs.find((attr) => attr.key.name === "lang");
if (!lang || !lang.value || lang.value.value === "html") {
continue;
}
}
this.blocks.push(block);
if (block.selfClosing) {
// Self-closing blocks are temporarily replaced with `<s---->` or `<t---->` tag
// because the svelte compiler cannot parse self-closing block(script, style) tags.
// It will be restored later in `convertHTMLElement()` processing.
templateCode += `${code.slice(start, block.startTagRange[0] + 2 /* `<` and first letter */)}${"-".repeat(block.tag.length - 1 /* skip first letter */)}${code.slice(block.startTagRange[0] + 1 /* skip `<` */ + block.tag.length, block.startTagRange[1])}`;
scriptCode += spaces.slice(start, block.startTagRange[1]);
start = block.startTagRange[1];
}
else {
templateCode +=
code.slice(start, block.contentRange[0]) +
spaces.slice(block.contentRange[0], block.contentRange[1]);
if (block.tag === "script") {
scriptCode +=
spaces.slice(start, block.contentRange[0]) +
code.slice(...block.contentRange);
for (const attr of block.attrs) {
scriptAttrs[attr.key.name] = (_a = attr.value) === null || _a === void 0 ? void 0 : _a.value;
}
}
else {
scriptCode += spaces.slice(start, block.contentRange[1]);
}
start = block.contentRange[1];
}
}
templateCode += code.slice(start);
scriptCode += spaces.slice(start);
this.sourceCode = {
template: templateCode,
scripts: new ScriptsSourceCode(scriptCode, scriptAttrs),
};
this.scriptLet = new script_let_1.ScriptLetContext(this);
}
getLocFromIndex(index) {
let loc = this.locsMap.get(index);
if (!loc) {
loc = this.locs.getLocFromIndex(index);
this.locsMap.set(index, loc);
}
return {
line: loc.line,
column: loc.column,
};
}
getIndexFromLoc(loc) {
return this.locs.getIndexFromLoc(loc);
}
/**
* Get the location information of the given node.
* @param node The node.
*/
getConvertLocation(node) {
const { start, end } = node;
return {
range: [start, end],
loc: {
start: this.getLocFromIndex(start),
end: this.getLocFromIndex(end),
},
};
}
addComment(comment) {
this.comments.push(comment);
}
/**
* Add token to tokens
*/
addToken(type, range) {
const token = Object.assign({ type, value: this.getText(range) }, this.getConvertLocation(range));
this.tokens.push(token);
return token;
}
/**
* get text
*/
getText(range) {
return this.code.slice(range.start, range.end);
}
isTypeScript() {
var _a, _b;
if (this.state.isTypeScript != null) {
return this.state.isTypeScript;
}
const lang = this.sourceCode.scripts.attrs.lang;
if (!lang) {
return (this.state.isTypeScript = false);
}
const parserValue = (0, resolve_parser_1.getParserForLang)(this.sourceCode.scripts.attrs, (_a = this.parserOptions) === null || _a === void 0 ? void 0 : _a.parser);
if (typeof parserValue !== "string") {
return (this.state.isTypeScript =
(0, parser_object_1.maybeTSESLintParserObject)(parserValue) ||
(0, parser_object_1.isTSESLintParserObject)(parserValue));
}
const parserName = parserValue;
if (TS_PARSER_NAMES.includes(parserName)) {
return (this.state.isTypeScript = true);
}
if (TS_PARSER_NAMES.some((nm) => parserName.includes(nm))) {
let targetPath = parserName;
while (targetPath) {
const pkgPath = path_1.default.join(targetPath, "package.json");
if (fs_1.default.existsSync(pkgPath)) {
try {
return (this.state.isTypeScript = TS_PARSER_NAMES.includes((_b = JSON.parse(fs_1.default.readFileSync(pkgPath, "utf-8"))) === null || _b === void 0 ? void 0 : _b.name));
}
catch (_c) {
return (this.state.isTypeScript = false);
}
}
const parent = path_1.default.dirname(targetPath);
if (targetPath === parent) {
break;
}
targetPath = parent;
}
}
return (this.state.isTypeScript = false);
}
stripScriptCode(start, end) {
this.sourceCode.scripts.stripCode(start, end);
}
findBlock(element) {
const tag = element.type === "SvelteScriptElement"
? "script"
: element.type === "SvelteStyleElement"
? "style"
: element.name.name.toLowerCase();
return this.blocks.find((block) => block.tag === tag &&
!block.selfClosing &&
element.range[0] <= block.contentRange[0] &&
block.contentRange[1] <= element.range[1]);
}
findSelfClosingBlock(element) {
return this.blocks.find((block) => Boolean(block.selfClosing &&
element.startTag.range[0] <= block.startTagRange[0] &&
block.startTagRange[1] <= element.startTag.range[1]));
}
}
exports.Context = Context;
/** Extract <script> blocks */
function* extractBlocks(code) {
const startTagOpenRe = /<!--[\s\S]*?-->|<(script|style|template)([\s>])/giu;
const endScriptTagRe = /<\/script>/giu;
const endStyleTagRe = /<\/style>/giu;
const endTemplateTagRe = /<\/template>/giu;
let startTagOpenMatch;
while ((startTagOpenMatch = startTagOpenRe.exec(code))) {
const [, tag, nextChar] = startTagOpenMatch;
if (!tag) {
continue;
}
const startTagStart = startTagOpenMatch.index;
let startTagEnd = startTagOpenRe.lastIndex;
const lowerTag = tag.toLowerCase();
let attrs = [];
if (!nextChar.trim()) {
const attrsData = (0, html_1.parseAttributes)(code, startTagOpenRe.lastIndex);
attrs = attrsData.attributes;
startTagEnd = attrsData.index;
if (code[startTagEnd] === "/" && code[startTagEnd + 1] === ">") {
yield {
tag: lowerTag,
originalTag: tag,
attrs,
selfClosing: true,
startTagRange: [startTagStart, startTagEnd + 2],
};
continue;
}
if (code[startTagEnd] === ">") {
startTagEnd++;
}
else {
continue;
}
}
const endTagRe = lowerTag === "script"
? endScriptTagRe
: lowerTag === "style"
? endStyleTagRe
: endTemplateTagRe;
endTagRe.lastIndex = startTagEnd;
const endTagMatch = endTagRe.exec(code);
if (endTagMatch) {
const endTagStart = endTagMatch.index;
const endTagEnd = endTagRe.lastIndex;
yield {
tag: lowerTag,
originalTag: tag,
attrs,
startTagRange: [startTagStart, startTagEnd],
contentRange: [startTagEnd, endTagStart],
endTagRange: [endTagStart, endTagEnd],
};
startTagOpenRe.lastIndex = endTagEnd;
}
}
}
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 = (0, utils_1.sortedLastIndex)(this.lineStartIndices, (target) => target - 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;
}
/**
* Get the location information of the given indexes.
*/
getLocations(start, end) {
return {
range: [start, end],
loc: {
start: this.getLocFromIndex(start),
end: this.getLocFromIndex(end),
},
};
}
}
exports.LinesAndColumns = LinesAndColumns;

15
node_modules/svelte-eslint-parser/lib/context/let-directive-collection.d.ts generated vendored Normal file
View File

@ -0,0 +1,15 @@
import type { SvelteLetDirective, SvelteName } from "../ast";
import type * as ESTree from "estree";
import type { ScriptLetBlockParam, ScriptLetCallback } from "./script-let";
/** A class that collects pattern nodes for Let directives. */
export declare class LetDirectiveCollection {
private readonly list;
getLetParams(): ScriptLetBlockParam[];
addPattern(pattern: ESTree.Pattern | SvelteName, directive: SvelteLetDirective, typing: string, ...callbacks: ScriptLetCallback<ESTree.Pattern>[]): ScriptLetCallback<ESTree.Pattern>[];
}
export declare class LetDirectiveCollections {
private readonly stack;
beginExtract(): void;
getCollection(): LetDirectiveCollection;
extract(): LetDirectiveCollection;
}

41
node_modules/svelte-eslint-parser/lib/context/let-directive-collection.js generated vendored Normal file
View File

@ -0,0 +1,41 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.LetDirectiveCollections = exports.LetDirectiveCollection = void 0;
/** A class that collects pattern nodes for Let directives. */
class LetDirectiveCollection {
constructor() {
this.list = [];
}
getLetParams() {
return this.list;
}
addPattern(pattern, directive, typing, ...callbacks) {
this.list.push({
node: pattern,
parent: directive,
typing,
callback(node, options) {
for (const callback of callbacks) {
callback(node, options);
}
},
});
return callbacks;
}
}
exports.LetDirectiveCollection = LetDirectiveCollection;
class LetDirectiveCollections {
constructor() {
this.stack = [];
}
beginExtract() {
this.stack.push(new LetDirectiveCollection());
}
getCollection() {
return this.stack[this.stack.length - 1];
}
extract() {
return this.stack.pop();
}
}
exports.LetDirectiveCollections = LetDirectiveCollections;

84
node_modules/svelte-eslint-parser/lib/context/script-let.d.ts generated vendored Normal file
View File

@ -0,0 +1,84 @@
import type { ScopeManager, Scope } from "eslint-scope";
import type * as ESTree from "estree";
import type { Context } from ".";
import type { Comment, SvelteEachBlock, SvelteIfBlock, SvelteName, SvelteNode, Token } from "../ast";
import type { ESLintExtendedProgram } from "../parser";
export type ScriptLetCallback<E extends ESTree.Node> = (es: E, options: ScriptLetCallbackOption) => void;
export type ScriptLetCallbackOption = {
getScope: (node: ESTree.Node) => Scope;
registerNodeToScope: (node: any, scope: Scope) => void;
scopeManager: ScopeManager;
visitorKeys?: {
[type: string]: string[];
};
};
export type ScriptLetRestoreCallback = (node: ESTree.Node, tokens: Token[], comments: Comment[], options: ScriptLetRestoreCallbackOption) => void;
type ScriptLetRestoreCallbackOption = {
getScope: (node: ESTree.Node) => Scope;
registerNodeToScope: (node: any, scope: Scope) => void;
scopeManager: ScopeManager;
visitorKeys?: {
[type: string]: string[];
};
addPostProcess: (callback: () => void) => void;
};
type TypeGenHelper = {
generateUniqueId: (base: string) => string;
};
type ObjectShorthandProperty = ESTree.Property & {
key: ESTree.Identifier;
value: ESTree.Identifier;
};
export type ScriptLetBlockParam = {
node: ESTree.Pattern | SvelteName;
parent: SvelteNode;
typing: string;
callback: (node: ESTree.Pattern, options: ScriptLetCallbackOption) => void;
};
/**
* A class that handles script fragments.
* The script fragment AST node remaps and connects to the original directive AST node.
*/
export declare class ScriptLetContext {
private readonly script;
private readonly ctx;
private readonly restoreCallbacks;
private readonly programRestoreCallbacks;
private readonly closeScopeCallbacks;
private readonly unique;
constructor(ctx: Context);
addExpression<E extends ESTree.Expression>(expression: E | SvelteName, parent: SvelteNode, typing?: string | null, ...callbacks: ScriptLetCallback<E>[]): ScriptLetCallback<E>[];
addObjectShorthandProperty(identifier: SvelteName, parent: SvelteNode, ...callbacks: ScriptLetCallback<ObjectShorthandProperty>[]): void;
addVariableDeclarator(expression: ESTree.AssignmentExpression, parent: SvelteNode, ...callbacks: ScriptLetCallback<ESTree.VariableDeclarator>[]): ScriptLetCallback<ESTree.VariableDeclarator>[];
nestIfBlock(expression: ESTree.Expression, ifBlock: SvelteIfBlock, callback: ScriptLetCallback<ESTree.Expression>): void;
nestEachBlock(expression: ESTree.Expression, context: ESTree.Pattern, indexRange: {
start: number;
end: number;
} | null, eachBlock: SvelteEachBlock, callback: (expr: ESTree.Expression, ctx: ESTree.Pattern, index: ESTree.Identifier | null) => void): void;
nestBlock(block: SvelteNode, params?: ScriptLetBlockParam[] | ((helper: TypeGenHelper | null) => {
param: ScriptLetBlockParam;
preparationScript?: string[];
})): void;
closeScope(): void;
addProgramRestore(callback: ScriptLetRestoreCallback): void;
private appendScript;
private appendScriptWithoutOffset;
private pushScope;
/**
* Restore AST nodes
*/
restore(result: ESLintExtendedProgram): void;
/**
* Restore AST nodes
*/
private restoreNodes;
/**
* Restore program node
*/
private restoreProgram;
private remapNodes;
/** Fix locations */
private fixLocations;
private generateUniqueId;
}
export {};

701
node_modules/svelte-eslint-parser/lib/context/script-let.js generated vendored Normal file
View File

@ -0,0 +1,701 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ScriptLetContext = void 0;
const common_1 = require("../parser/converts/common");
const scope_1 = require("../scope");
const traverse_1 = require("../traverse");
const unique_1 = require("./unique");
/**
* Get node range
*/
function getNodeRange(node) {
let start = null;
let end = null;
if (node.leadingComments) {
start = (0, common_1.getWithLoc)(node.leadingComments[0]).start;
}
if (node.trailingComments) {
end = (0, common_1.getWithLoc)(node.trailingComments[node.trailingComments.length - 1]).end;
}
const loc = "range" in node
? { start: node.range[0], end: node.range[1] }
: (0, common_1.getWithLoc)(node);
return [
start ? Math.min(start, loc.start) : loc.start,
end ? Math.max(end, loc.end) : loc.end,
];
}
/**
* A class that handles script fragments.
* The script fragment AST node remaps and connects to the original directive AST node.
*/
class ScriptLetContext {
constructor(ctx) {
this.restoreCallbacks = [];
this.programRestoreCallbacks = [];
this.closeScopeCallbacks = [];
this.unique = new unique_1.UniqueIdGenerator();
this.script = ctx.sourceCode.scripts;
this.ctx = ctx;
}
addExpression(expression, parent, typing, ...callbacks) {
const range = getNodeRange(expression);
const part = this.ctx.code.slice(...range);
const isTS = typing && this.ctx.isTypeScript();
this.appendScript(`(${part})${isTS ? `as (${typing})` : ""};`, range[0] - 1, (st, tokens, comments, result) => {
const exprSt = st;
const tsAs = isTS
? exprSt.expression
: null;
const node = (tsAs === null || tsAs === void 0 ? void 0 : tsAs.expression) || exprSt.expression;
// Process for nodes
for (const callback of callbacks) {
callback(node, result);
}
if (isTS) {
for (const scope of extractTypeNodeScopes(tsAs.typeAnnotation, result)) {
(0, scope_1.removeScope)(result.scopeManager, scope);
}
this.remapNodes([
{
offset: range[0] - 1,
range,
newNode: node,
},
], tokens, comments, result.visitorKeys);
}
node.parent = parent;
tokens.shift(); // (
tokens.pop(); // )
tokens.pop(); // ;
// Disconnect the tree structure.
exprSt.expression = null;
});
return callbacks;
}
addObjectShorthandProperty(identifier, parent, ...callbacks) {
const range = getNodeRange(identifier);
const part = this.ctx.code.slice(...range);
this.appendScript(`({${part}});`, range[0] - 2, (st, tokens, _comments, result) => {
const exprSt = st;
const objectExpression = exprSt.expression;
const node = objectExpression.properties[0];
// Process for nodes
for (const callback of callbacks) {
callback(node, result);
}
node.key.parent = parent;
node.value.parent = parent;
tokens.shift(); // (
tokens.shift(); // {
tokens.pop(); // }
tokens.pop(); // )
tokens.pop(); // ;
// Disconnect the tree structure.
exprSt.expression = null;
});
}
addVariableDeclarator(expression, parent, ...callbacks) {
const range = getNodeRange(expression);
const part = this.ctx.code.slice(...range);
this.appendScript(`const ${part};`, range[0] - 6, (st, tokens, _comments, result) => {
const decl = st;
const node = decl.declarations[0];
// Process for nodes
for (const callback of callbacks) {
callback(node, result);
}
const scope = result.getScope(decl);
for (const variable of scope.variables) {
for (const def of variable.defs) {
if (def.parent === decl) {
def.parent = parent;
}
}
}
node.parent = parent;
tokens.shift(); // const
tokens.pop(); // ;
// Disconnect the tree structure.
decl.declarations = [];
});
return callbacks;
}
nestIfBlock(expression, ifBlock, callback) {
const range = getNodeRange(expression);
const part = this.ctx.code.slice(...range);
const restore = this.appendScript(`if(${part}){`, range[0] - 3, (st, tokens, _comments, result) => {
const ifSt = st;
const node = ifSt.test;
const scope = result.getScope(ifSt.consequent);
// Process for nodes
callback(node, result);
node.parent = ifBlock;
// Process for scope
result.registerNodeToScope(ifBlock, scope);
tokens.shift(); // if
tokens.shift(); // (
tokens.pop(); // )
tokens.pop(); // {
tokens.pop(); // }
// Disconnect the tree structure.
ifSt.test = null;
ifSt.consequent = null;
});
this.pushScope(restore, "}");
}
nestEachBlock(expression, context, indexRange, eachBlock, callback) {
const exprRange = getNodeRange(expression);
const ctxRange = getNodeRange(context);
let source = "Array.from(";
const exprOffset = source.length;
source += `${this.ctx.code.slice(...exprRange)}).forEach((`;
const ctxOffset = source.length;
source += this.ctx.code.slice(...ctxRange);
let idxOffset = null;
if (indexRange) {
source += ",";
idxOffset = source.length;
source += this.ctx.code.slice(indexRange.start, indexRange.end);
}
source += ")=>{";
const restore = this.appendScript(source, exprRange[0] - exprOffset, (st, tokens, comments, result) => {
var _a;
const expSt = st;
const call = expSt.expression;
const fn = call.arguments[0];
const callArrayFrom = call.callee
.object;
const expr = callArrayFrom.arguments[0];
const ctx = fn.params[0];
const idx = ((_a = fn.params[1]) !== null && _a !== void 0 ? _a : null);
const scope = result.getScope(fn.body);
// Process for nodes
callback(expr, ctx, idx);
// Process for scope
result.registerNodeToScope(eachBlock, scope);
for (const v of scope.variables) {
for (const def of v.defs) {
if (def.node === fn) {
def.node = eachBlock;
}
}
}
// remove Array reference
const arrayId = callArrayFrom.callee
.object;
const ref = scope.upper.references.find((r) => r.identifier === arrayId);
if (ref) {
(0, scope_1.removeReference)(ref, scope.upper);
}
expr.parent = eachBlock;
ctx.parent = eachBlock;
if (idx) {
idx.parent = eachBlock;
}
tokens.shift(); // Array
tokens.shift(); // .
tokens.shift(); // from
tokens.shift(); // (
tokens.pop(); // )
tokens.pop(); // =>
tokens.pop(); // {
tokens.pop(); // }
tokens.pop(); // )
tokens.pop(); // ;
const map = [
{
offset: exprOffset,
range: exprRange,
newNode: expr,
},
{
offset: ctxOffset,
range: ctxRange,
newNode: ctx,
},
];
if (indexRange) {
map.push({
offset: idxOffset,
range: [indexRange.start, indexRange.end],
newNode: idx,
});
}
this.remapNodes(map, tokens, comments, result.visitorKeys);
// Disconnect the tree structure.
expSt.expression = null;
});
this.pushScope(restore, "});");
}
nestBlock(block, params) {
let resolvedParams;
if (typeof params === "function") {
if (this.ctx.isTypeScript()) {
const generatedTypes = params({
generateUniqueId: (base) => this.generateUniqueId(base),
});
resolvedParams = [generatedTypes.param];
if (generatedTypes.preparationScript) {
for (const preparationScript of generatedTypes.preparationScript) {
this.appendScriptWithoutOffset(preparationScript, (node, tokens, comments, result) => {
tokens.length = 0;
comments.length = 0;
(0, scope_1.removeAllScopeAndVariableAndReference)(node, result);
});
}
}
}
else {
const generatedTypes = params(null);
resolvedParams = [generatedTypes.param];
}
}
else {
resolvedParams = params;
}
if (!resolvedParams || resolvedParams.length === 0) {
const restore = this.appendScript(`{`, block.range[0], (st, tokens, _comments, result) => {
const blockSt = st;
// Process for scope
const scope = result.getScope(blockSt);
result.registerNodeToScope(block, scope);
tokens.length = 0; // clear tokens
// Disconnect the tree structure.
blockSt.body = null;
});
this.pushScope(restore, "}");
}
else {
const sortedParams = [...resolvedParams]
.map((d) => {
return Object.assign(Object.assign({}, d), { range: getNodeRange(d.node) });
})
.sort((a, b) => {
const [pA] = a.range;
const [pB] = b.range;
return pA - pB;
});
const maps = [];
let source = "";
for (let index = 0; index < sortedParams.length; index++) {
const param = sortedParams[index];
const range = param.range;
if (source) {
source += ",";
}
const offset = source.length + 1; /* ( */
source += this.ctx.code.slice(...range);
maps.push({
index: maps.length,
offset,
range,
});
if (this.ctx.isTypeScript()) {
source += `: (${param.typing})`;
}
}
const restore = this.appendScript(`(${source})=>{`, maps[0].range[0] - 1, (st, tokens, comments, result) => {
const exprSt = st;
const fn = exprSt.expression;
const scope = result.getScope(fn.body);
// Process for nodes
for (let index = 0; index < fn.params.length; index++) {
const p = fn.params[index];
sortedParams[index].callback(p, result);
if (this.ctx.isTypeScript()) {
const typeAnnotation = p.typeAnnotation;
delete p.typeAnnotation;
p.range[1] = typeAnnotation.range[0];
p.loc.end = {
line: typeAnnotation.loc.start.line,
column: typeAnnotation.loc.start.column,
};
(0, scope_1.removeAllScopeAndVariableAndReference)(typeAnnotation, result);
}
p.parent = sortedParams[index].parent;
}
// Process for scope
result.registerNodeToScope(block, scope);
for (const v of scope.variables) {
for (const def of v.defs) {
if (def.node === fn) {
def.node = block;
}
}
}
tokens.shift(); // (
tokens.pop(); // )
tokens.pop(); // =>
tokens.pop(); // {
tokens.pop(); // }
tokens.pop(); // ;
this.remapNodes(maps.map((m) => {
return {
offset: m.offset,
range: m.range,
newNode: fn.params[m.index],
};
}), tokens, comments, result.visitorKeys);
// Disconnect the tree structure.
exprSt.expression = null;
});
this.pushScope(restore, "};");
}
}
closeScope() {
this.closeScopeCallbacks.pop()();
}
addProgramRestore(callback) {
this.programRestoreCallbacks.push(callback);
}
appendScript(text, offset, callback) {
const resultCallback = this.appendScriptWithoutOffset(text, (node, tokens, comments, result) => {
this.fixLocations(node, tokens, comments, offset - resultCallback.start, result.visitorKeys);
callback(node, tokens, comments, result);
});
return resultCallback;
}
appendScriptWithoutOffset(text, callback) {
const { start: startOffset, end: endOffset } = this.script.addLet(text);
const restoreCallback = {
start: startOffset,
end: endOffset,
callback,
};
this.restoreCallbacks.push(restoreCallback);
return restoreCallback;
}
pushScope(restoreCallback, closeToken) {
this.closeScopeCallbacks.push(() => {
this.script.addLet(closeToken);
restoreCallback.end = this.script.getCurrentVirtualCodeLength();
});
}
/**
* Restore AST nodes
*/
restore(result) {
const nodeToScope = getNodeToScope(result.scopeManager);
const postprocessList = [];
const callbackOption = {
getScope,
registerNodeToScope,
scopeManager: result.scopeManager,
visitorKeys: result.visitorKeys,
addPostProcess: (cb) => postprocessList.push(cb),
};
this.restoreNodes(result, callbackOption);
this.restoreProgram(result, callbackOption);
postprocessList.forEach((p) => p());
// Helpers
/** Get scope */
function getScope(node) {
return (0, scope_1.getScopeFromNode)(result.scopeManager, node);
}
/** Register node to scope */
function registerNodeToScope(node, scope) {
// If we replace the `scope.block` at this time,
// the scope restore calculation will not work, so we will replace the `scope.block` later.
postprocessList.push(() => {
scope.block = node;
});
const scopes = nodeToScope.get(node);
if (scopes) {
scopes.push(scope);
}
else {
nodeToScope.set(node, [scope]);
}
}
}
/**
* Restore AST nodes
*/
restoreNodes(result, callbackOption) {
let orderedRestoreCallback = this.restoreCallbacks.shift();
if (!orderedRestoreCallback) {
return;
}
const separateIndexes = this.script.separateIndexes;
const tokens = result.ast.tokens;
const processedTokens = [];
const comments = result.ast.comments;
const processedComments = [];
let tok;
while ((tok = tokens.shift())) {
if (separateIndexes.includes(tok.range[0]) && tok.value === ";") {
break;
}
if (orderedRestoreCallback.start <= tok.range[0]) {
tokens.unshift(tok);
break;
}
processedTokens.push(tok);
}
while ((tok = comments.shift())) {
if (orderedRestoreCallback.start <= tok.range[0]) {
comments.unshift(tok);
break;
}
processedComments.push(tok);
}
const targetNodes = new Map();
const removeStatements = [];
(0, traverse_1.traverseNodes)(result.ast, {
visitorKeys: result.visitorKeys,
enterNode: (node) => {
while (node.range && separateIndexes.includes(node.range[1] - 1)) {
node.range[1]--;
node.loc.end.column--;
}
if (node.loc.end.column < 0) {
node.loc.end = this.ctx.getLocFromIndex(node.range[1]);
}
if (node.parent === result.ast &&
separateIndexes[0] <= node.range[0]) {
removeStatements.push(node);
}
if (!orderedRestoreCallback) {
return;
}
if (orderedRestoreCallback.start <= node.range[0] &&
node.range[1] <= orderedRestoreCallback.end) {
targetNodes.set(node, orderedRestoreCallback);
orderedRestoreCallback = this.restoreCallbacks.shift();
}
//
},
leaveNode(node) {
const restoreCallback = targetNodes.get(node);
if (!restoreCallback) {
return;
}
const startIndex = {
token: tokens.findIndex((t) => restoreCallback.start <= t.range[0]),
comment: comments.findIndex((t) => restoreCallback.start <= t.range[0]),
};
if (startIndex.comment === -1) {
startIndex.comment = comments.length;
}
const endIndex = {
token: tokens.findIndex((t) => restoreCallback.end < t.range[1], startIndex.token),
comment: comments.findIndex((t) => restoreCallback.end < t.range[1], startIndex.comment),
};
if (endIndex.token === -1) {
endIndex.token = tokens.length;
}
if (endIndex.comment === -1) {
endIndex.comment = comments.length;
}
const targetTokens = tokens.splice(startIndex.token, endIndex.token - startIndex.token);
const targetComments = comments.splice(startIndex.comment, endIndex.comment - startIndex.comment);
restoreCallback.callback(node, targetTokens, targetComments, callbackOption);
processedTokens.push(...targetTokens);
processedComments.push(...targetComments);
},
});
for (const st of removeStatements) {
const index = result.ast.body.indexOf(st);
result.ast.body.splice(index, 1);
}
result.ast.tokens = processedTokens;
result.ast.comments = processedComments;
}
/**
* Restore program node
*/
restoreProgram(result, callbackOption) {
for (const callback of this.programRestoreCallbacks) {
callback(result.ast, result.ast.tokens, result.ast.comments, callbackOption);
}
}
remapNodes(maps, tokens, comments, visitorKeys) {
const targetMaps = [...maps];
const first = targetMaps.shift();
let tokenIndex = 0;
for (; tokenIndex < tokens.length; tokenIndex++) {
const token = tokens[tokenIndex];
if (first.range[1] <= token.range[0]) {
break;
}
}
for (const map of targetMaps) {
const startOffset = map.offset - first.offset + first.range[0];
const endOffset = startOffset + (map.range[1] - map.range[0]);
let removeCount = 0;
let target = tokens[tokenIndex];
while (target && target.range[1] <= startOffset) {
removeCount++;
target = tokens[tokenIndex + removeCount];
}
if (removeCount) {
tokens.splice(tokenIndex, removeCount);
}
const bufferTokens = [];
for (; tokenIndex < tokens.length; tokenIndex++) {
const token = tokens[tokenIndex];
if (endOffset <= token.range[0]) {
break;
}
bufferTokens.push(token);
}
this.fixLocations(map.newNode, bufferTokens, comments.filter((t) => startOffset <= t.range[0] && t.range[1] <= endOffset), map.range[0] - startOffset, visitorKeys);
}
tokens.splice(tokenIndex);
}
/** Fix locations */
fixLocations(node, tokens, comments, offset, visitorKeys) {
if (offset === 0) {
return;
}
const traversed = new Set();
(0, traverse_1.traverseNodes)(node, {
visitorKeys,
enterNode: (n) => {
if (traversed.has(n)) {
return;
}
traversed.add(n);
if (traversed.has(n.range)) {
if (!traversed.has(n.loc)) {
// However, `Node#loc` may not be shared.
const locs = this.ctx.getConvertLocation({
start: n.range[0],
end: n.range[1],
});
applyLocs(n, locs);
traversed.add(n.loc);
}
}
else {
const start = n.range[0] + offset;
const end = n.range[1] + offset;
const locs = this.ctx.getConvertLocation({ start, end });
applyLocs(n, locs);
traversed.add(n.range);
traversed.add(n.loc);
}
},
leaveNode: Function.prototype,
});
for (const t of tokens) {
const start = t.range[0] + offset;
const end = t.range[1] + offset;
const locs = this.ctx.getConvertLocation({ start, end });
applyLocs(t, locs);
}
for (const t of comments) {
const start = t.range[0] + offset;
const end = t.range[1] + offset;
const locs = this.ctx.getConvertLocation({ start, end });
applyLocs(t, locs);
}
}
generateUniqueId(base) {
return this.unique.generate(base, this.ctx.code, this.script.getCurrentVirtualCode());
}
}
exports.ScriptLetContext = ScriptLetContext;
/**
* applyLocs
*/
function applyLocs(target, locs) {
target.loc = locs.loc;
target.range = locs.range;
if (typeof target.start === "number") {
delete target.start;
}
if (typeof target.end === "number") {
delete target.end;
}
}
/** Get the node to scope map from given scope manager */
function getNodeToScope(scopeManager) {
if ("__nodeToScope" in scopeManager) {
return scopeManager.__nodeToScope;
}
// transform scopeManager
const nodeToScope = new WeakMap();
for (const scope of scopeManager.scopes) {
const scopes = nodeToScope.get(scope.block);
if (scopes) {
scopes.push(scope);
}
else {
nodeToScope.set(scope.block, [scope]);
}
}
scopeManager.acquire = function (node, inner) {
/**
* predicate
*/
function predicate(testScope) {
if (testScope.type === "function" && testScope.functionExpressionScope) {
return false;
}
return true;
}
const scopes = nodeToScope.get(node);
if (!scopes || scopes.length === 0) {
return null;
}
// Heuristic selection from all scopes.
// If you would like to get all scopes, please use ScopeManager#acquireAll.
if (scopes.length === 1) {
return scopes[0];
}
if (inner) {
for (let i = scopes.length - 1; i >= 0; --i) {
const scope = scopes[i];
if (predicate(scope)) {
return scope;
}
}
}
else {
for (let i = 0, iz = scopes.length; i < iz; ++i) {
const scope = scopes[i];
if (predicate(scope)) {
return scope;
}
}
}
return null;
};
return nodeToScope;
}
/** Extract the type scope of the given node. */
function extractTypeNodeScopes(node, result) {
const scopes = new Set();
for (const scope of iterateTypeNodeScopes(node)) {
scopes.add(scope);
}
return scopes;
/** Iterate the type scope of the given node. */
function* iterateTypeNodeScopes(node) {
if (node.type === "TSParenthesizedType") {
// Skip TSParenthesizedType.
yield* iterateTypeNodeScopes(node.typeAnnotation);
}
else if (node.type === "TSConditionalType") {
yield result.getScope(node);
// `falseType` of `TSConditionalType` is sibling scope.
const falseType = node.falseType;
yield* iterateTypeNodeScopes(falseType);
}
else if (node.type === "TSFunctionType" ||
node.type === "TSMappedType" ||
node.type === "TSConstructorType") {
yield result.getScope(node);
}
else {
const typeNode = node;
for (const key of (0, traverse_1.getKeys)(typeNode, result.visitorKeys)) {
for (const child of (0, traverse_1.getNodes)(typeNode, key)) {
yield* iterateTypeNodeScopes(child);
}
}
}
}
}

5
node_modules/svelte-eslint-parser/lib/context/unique.d.ts generated vendored Normal file
View File

@ -0,0 +1,5 @@
export declare class UniqueIdGenerator {
private uniqueIdSeq;
private readonly usedUniqueIds;
generate(base: string, ...texts: string[]): string;
}

19
node_modules/svelte-eslint-parser/lib/context/unique.js generated vendored Normal file
View File

@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.UniqueIdGenerator = void 0;
class UniqueIdGenerator {
constructor() {
this.uniqueIdSeq = 1;
this.usedUniqueIds = new Set();
}
generate(base, ...texts) {
const hasId = (id) => this.usedUniqueIds.has(id) || texts.some((t) => t.includes(id));
let candidate = `$_${base.replace(/\W/g, "_")}${this.uniqueIdSeq++}`;
while (hasId(candidate)) {
candidate = `$_${base.replace(/\W/g, "_")}${this.uniqueIdSeq++}`;
}
this.usedUniqueIds.add(candidate);
return candidate;
}
}
exports.UniqueIdGenerator = UniqueIdGenerator;