@vue/language-core 2.0.0 → 2.0.2

package/lib/generators/utils.d.ts

@@ -0,0 +1,6 @@
+import type { Code, CodeAndStack, VueCodeInformation } from '../types';
+export declare function withStack(code: Code): CodeAndStack;
+export declare function getStack(): string;
+export declare function disableAllFeatures(override: Partial<VueCodeInformation>): VueCodeInformation;
+export declare function enableAllFeatures(override: Partial<VueCodeInformation>): VueCodeInformation;
+export declare function mergeFeatureSettings(base: VueCodeInformation, ...others: Partial<VueCodeInformation>[]): VueCodeInformation;

package/lib/generators/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeFeatureSettings = exports.enableAllFeatures = exports.disableAllFeatures = exports.getStack = exports.withStack = void 0;
+function withStack(code) {
+    return [code, getStack()];
+}
+exports.withStack = withStack;
+// TODO: import from muggle-string
+function getStack() {
+    const stack = new Error().stack;
+    let source = stack.split('\n')[3].trim();
+    if (source.endsWith(')')) {
+        source = source.slice(source.lastIndexOf('(') + 1, -1);
+    }
+    else {
+        source = source.slice(source.lastIndexOf(' ') + 1);
+    }
+    return source;
+}
+exports.getStack = getStack;
+function disableAllFeatures(override) {
+    return {
+        verification: false,
+        completion: false,
+        semantic: false,
+        navigation: false,
+        structure: false,
+        format: false,
+        ...override,
+    };
+}
+exports.disableAllFeatures = disableAllFeatures;
+function enableAllFeatures(override) {
+    return {
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+        structure: true,
+        format: true,
+        ...override,
+    };
+}
+exports.enableAllFeatures = enableAllFeatures;
+function mergeFeatureSettings(base, ...others) {
+    const result = { ...base };
+    for (const info of others) {
+        for (const key in info) {
+            const value = info[key];
+            if (value) {
+                result[key] = value;
+            }
+        }
+    }
+    return result;
+}
+exports.mergeFeatureSettings = mergeFeatureSettings;
+//# sourceMappingURL=utils.js.map

package/lib/languageModule.d.ts

@@ -0,0 +1,5 @@
+import { type LanguagePlugin } from '@volar/language-core';
+import type * as ts from 'typescript';
+import type { VueCompilerOptions } from './types';
+import { VueGeneratedCode } from './virtualFile/vueFile';
+export declare function createVueLanguagePlugin(ts: typeof import('typescript'), getFileName: (fileId: string) => string, compilerOptions?: ts.CompilerOptions, _vueCompilerOptions?: Partial<VueCompilerOptions>, codegenStack?: boolean, globalTypesHolder?: string): LanguagePlugin<VueGeneratedCode>;

package/lib/languageModule.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVueLanguagePlugin = void 0;
+const language_core_1 = require("@volar/language-core");
+const plugins_1 = require("./plugins");
+const ts_1 = require("./utils/ts");
+const vueFile_1 = require("./virtualFile/vueFile");
+const fileRegistries = [];
+function getVueFileRegistry(key, plugins) {
+    let fileRegistry = fileRegistries.find(r => r.key === key
+        && r.plugins.length === plugins.length
+        && r.plugins.every(plugin => plugins.includes(plugin)))?.files;
+    if (!fileRegistry) {
+        fileRegistry = new Map();
+        fileRegistries.push({
+            key: key,
+            plugins: plugins,
+            files: fileRegistry,
+        });
+    }
+    return fileRegistry;
+}
+function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins, globalTypesHolder) {
+    const values = [
+        globalTypesHolder,
+        ...Object.keys(vueCompilerOptions)
+            .sort()
+            .filter(key => key !== 'plugins')
+            .map(key => [key, vueCompilerOptions[key]]),
+        [...new Set(plugins.map(plugin => plugin.requiredCompilerOptions ?? []).flat())]
+            .sort()
+            .map(key => [key, compilerOptions[key]]),
+    ];
+    return JSON.stringify(values);
+}
+function createVueLanguagePlugin(ts, getFileName, compilerOptions = {}, _vueCompilerOptions = {}, codegenStack = false, globalTypesHolder) {
+    const vueCompilerOptions = (0, ts_1.resolveVueCompilerOptions)(_vueCompilerOptions);
+    const allowLanguageIds = new Set(['vue']);
+    const pluginContext = (0, plugins_1.createPluginContext)(ts, compilerOptions, vueCompilerOptions, codegenStack, globalTypesHolder);
+    const plugins = (0, plugins_1.getDefaultVueLanguagePlugins)(pluginContext);
+    if (vueCompilerOptions.extensions.includes('.md')) {
+        allowLanguageIds.add('markdown');
+    }
+    if (vueCompilerOptions.extensions.includes('.html')) {
+        allowLanguageIds.add('html');
+    }
+    let generatedCodeRegistry;
+    return {
+        createVirtualCode(fileId, languageId, snapshot) {
+            if (allowLanguageIds.has(languageId)) {
+                const fileName = getFileName(fileId);
+                if (!generatedCodeRegistry) {
+                    pluginContext.globalTypesHolder ??= fileName;
+                    generatedCodeRegistry = getVueFileRegistry(getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins, pluginContext.globalTypesHolder), vueCompilerOptions.plugins);
+                }
+                if (generatedCodeRegistry.has(fileId)) {
+                    const reusedResult = generatedCodeRegistry.get(fileId);
+                    reusedResult.update(snapshot);
+                    return reusedResult;
+                }
+                const vueFile = new vueFile_1.VueGeneratedCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts, codegenStack);
+                generatedCodeRegistry.set(fileId, vueFile);
+                return vueFile;
+            }
+        },
+        updateVirtualCode(_fileId, vueFile, snapshot) {
+            vueFile.update(snapshot);
+            return vueFile;
+        },
+        disposeVirtualCode(fileId, vueFile, files) {
+            generatedCodeRegistry?.delete(fileId);
+            if (vueFile.fileName === pluginContext.globalTypesHolder) {
+                if (generatedCodeRegistry?.size) {
+                    for (const [fileName, file] of generatedCodeRegistry) {
+                        pluginContext.globalTypesHolder = fileName;
+                        generatedCodeRegistry = getVueFileRegistry(getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins, pluginContext.globalTypesHolder), vueCompilerOptions.plugins);
+                        files?.set(fileId, file.languageId, 
+                        // force dirty
+                        { ...file.snapshot });
+                        break;
+                    }
+                }
+                else {
+                    generatedCodeRegistry = undefined;
+                    pluginContext.globalTypesHolder = undefined;
+                }
+            }
+        },
+        typescript: {
+            extraFileExtensions: vueCompilerOptions.extensions.map(ext => ({
+                extension: ext.slice(1),
+                isMixedContent: true,
+                scriptKind: 7,
+            })),
+            getScript(rootVirtualCode) {
+                for (const code of (0, language_core_1.forEachEmbeddedCode)(rootVirtualCode)) {
+                    if (code.id.startsWith('script_')) {
+                        const lang = code.id.substring('script_'.length);
+                        return {
+                            code,
+                            extension: '.' + lang,
+                            scriptKind: lang === 'js' ? ts.ScriptKind.JS
+                                : lang === 'jsx' ? ts.ScriptKind.JSX
+                                    : lang === 'tsx' ? ts.ScriptKind.TSX
+                                        : ts.ScriptKind.TS,
+                        };
+                    }
+                }
+            },
+        },
+    };
+}
+exports.createVueLanguagePlugin = createVueLanguagePlugin;
+//# sourceMappingURL=languageModule.js.map

package/lib/parsers/scriptRanges.d.ts

@@ -0,0 +1,15 @@
+import type { TextRange } from '../types';
+import type * as ts from 'typescript';
+export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
+}
+export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, hasScriptSetup: boolean, withNode: boolean): {
+    exportDefault: (TextRange & {
+        expression: TextRange;
+        args: TextRange;
+        argsNode: ts.ObjectLiteralExpression | undefined;
+        componentsOption: TextRange | undefined;
+        componentsOptionNode: ts.ObjectLiteralExpression | undefined;
+        nameOption: TextRange | undefined;
+    }) | undefined;
+    bindings: TextRange[];
+};

package/lib/parsers/scriptRanges.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScriptRanges = void 0;
+const scriptSetupRanges_1 = require("./scriptSetupRanges");
+function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
+    let exportDefault;
+    const bindings = hasScriptSetup ? (0, scriptSetupRanges_1.parseBindingRanges)(ts, ast) : [];
+    ts.forEachChild(ast, raw => {
+        if (ts.isExportAssignment(raw)) {
+            let node = raw;
+            while (isAsExpression(node.expression) || ts.isParenthesizedExpression(node.expression)) { // fix https://github.com/vuejs/language-tools/issues/1882
+                node = node.expression;
+            }
+            let obj;
+            if (ts.isObjectLiteralExpression(node.expression)) {
+                obj = node.expression;
+            }
+            else if (ts.isCallExpression(node.expression) && node.expression.arguments.length) {
+                const arg0 = node.expression.arguments[0];
+                if (ts.isObjectLiteralExpression(arg0)) {
+                    obj = arg0;
+                }
+            }
+            if (obj) {
+                let componentsOptionNode;
+                let nameOptionNode;
+                ts.forEachChild(obj, node => {
+                    if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
+                        const name = (0, scriptSetupRanges_1.getNodeText)(ts, node.name, ast);
+                        if (name === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
+                            componentsOptionNode = node.initializer;
+                        }
+                        if (name === 'name') {
+                            nameOptionNode = node.initializer;
+                        }
+                    }
+                });
+                exportDefault = {
+                    ..._getStartEnd(raw),
+                    expression: _getStartEnd(node.expression),
+                    args: _getStartEnd(obj),
+                    argsNode: withNode ? obj : undefined,
+                    componentsOption: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
+                    componentsOptionNode: withNode ? componentsOptionNode : undefined,
+                    nameOption: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
+                };
+            }
+        }
+    });
+    return {
+        exportDefault,
+        bindings,
+    };
+    function _getStartEnd(node) {
+        return (0, scriptSetupRanges_1.getStartEnd)(ts, node, ast);
+    }
+    // isAsExpression is missing in tsc
+    function isAsExpression(node) {
+        return node.kind === ts.SyntaxKind.AsExpression;
+    }
+}
+exports.parseScriptRanges = parseScriptRanges;
+//# sourceMappingURL=scriptRanges.js.map

package/lib/parsers/scriptSetupRanges.d.ts

@@ -0,0 +1,57 @@
+import type * as ts from 'typescript';
+import type { VueCompilerOptions, TextRange } from '../types';
+export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRanges> {
+}
+export declare function parseScriptSetupRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
+    leadingCommentEndOffset: number;
+    importSectionEndOffset: number;
+    bindings: TextRange[];
+    props: {
+        name?: string | undefined;
+        define?: (TextRange & {
+            arg?: TextRange | undefined;
+            typeArg?: TextRange | undefined;
+        } & {
+            statement: TextRange;
+        }) | undefined;
+        withDefaults?: (TextRange & {
+            arg?: TextRange | undefined;
+        }) | undefined;
+    };
+    slots: {
+        name?: string | undefined;
+        define?: (TextRange & {
+            arg?: TextRange | undefined;
+            typeArg?: TextRange | undefined;
+        }) | undefined;
+    };
+    emits: {
+        name?: string | undefined;
+        define?: (TextRange & {
+            arg?: TextRange | undefined;
+            typeArg?: TextRange | undefined;
+        }) | undefined;
+    };
+    expose: {
+        name?: string | undefined;
+        define?: (TextRange & {
+            arg?: TextRange | undefined;
+            typeArg?: TextRange | undefined;
+        }) | undefined;
+    };
+    defineProp: {
+        name: TextRange | undefined;
+        nameIsString: boolean;
+        type: TextRange | undefined;
+        defaultValue: TextRange | undefined;
+        required: boolean;
+        isModel?: boolean | undefined;
+    }[];
+};
+export declare function parseBindingRanges(ts: typeof import('typescript'), sourceFile: ts.SourceFile): TextRange[];
+export declare function findBindingVars(ts: typeof import('typescript'), left: ts.BindingName, sourceFile: ts.SourceFile): TextRange[];
+export declare function getStartEnd(ts: typeof import('typescript'), node: ts.Node, sourceFile: ts.SourceFile): {
+    start: number;
+    end: number;
+};
+export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, sourceFile: ts.SourceFile): string;

package/lib/parsers/scriptSetupRanges.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeText = exports.getStartEnd = exports.findBindingVars = exports.parseBindingRanges = exports.parseScriptSetupRanges = void 0;
+function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
+    let foundNonImportExportNode = false;
+    let importSectionEndOffset = 0;
+    const props = {};
+    const slots = {};
+    const emits = {};
+    const expose = {};
+    const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition' || ast.text.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition');
+    const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition' || ast.text.trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition');
+    const defineProp = [];
+    const bindings = parseBindingRanges(ts, ast);
+    const text = ast.text;
+    const leadingCommentEndOffset = ts.getLeadingCommentRanges(text, 0)?.reverse()[0].end ?? 0;
+    ts.forEachChild(ast, node => {
+        const isTypeExport = (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) && node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
+        if (!foundNonImportExportNode
+            && !ts.isImportDeclaration(node)
+            && !isTypeExport
+            && !ts.isEmptyStatement(node)
+            // fix https://github.com/vuejs/language-tools/issues/1223
+            && !ts.isImportEqualsDeclaration(node)) {
+            const commentRanges = ts.getLeadingCommentRanges(text, node.pos);
+            if (commentRanges?.length) {
+                const commentRange = commentRanges.sort((a, b) => a.pos - b.pos)[0];
+                importSectionEndOffset = commentRange.pos;
+            }
+            else {
+                importSectionEndOffset = getStartEnd(ts, node, ast).start;
+            }
+            foundNonImportExportNode = true;
+        }
+    });
+    ts.forEachChild(ast, child => visitNode(child, [ast]));
+    return {
+        leadingCommentEndOffset,
+        importSectionEndOffset,
+        bindings,
+        props,
+        slots,
+        emits,
+        expose,
+        defineProp,
+    };
+    function _getStartEnd(node) {
+        return getStartEnd(ts, node, ast);
+    }
+    function parseDefineFunction(node) {
+        return {
+            ..._getStartEnd(node),
+            arg: node.arguments.length ? _getStartEnd(node.arguments[0]) : undefined,
+            typeArg: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+        };
+    }
+    function visitNode(node, parents) {
+        const parent = parents[parents.length - 1];
+        if (ts.isCallExpression(node)
+            && ts.isIdentifier(node.expression)) {
+            const callText = getNodeText(ts, node.expression, ast);
+            if (vueCompilerOptions.macros.defineModel.includes(callText)) {
+                let name;
+                let options;
+                if (node.arguments.length >= 2) {
+                    name = _getStartEnd(node.arguments[0]);
+                    options = node.arguments[1];
+                }
+                else if (node.arguments.length >= 1) {
+                    if (ts.isStringLiteral(node.arguments[0])) {
+                        name = _getStartEnd(node.arguments[0]);
+                    }
+                    else {
+                        options = node.arguments[0];
+                    }
+                }
+                let required = false;
+                if (options && ts.isObjectLiteralExpression(options)) {
+                    for (const property of options.properties) {
+                        if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && getNodeText(ts, property.name, ast) === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                            required = true;
+                            break;
+                        }
+                    }
+                }
+                defineProp.push({
+                    name,
+                    nameIsString: true,
+                    type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                    defaultValue: undefined,
+                    required,
+                    isModel: true,
+                });
+            }
+            else if (callText === 'defineProp') {
+                if (definePropProposalA) {
+                    let required = false;
+                    if (node.arguments.length >= 2) {
+                        const secondArg = node.arguments[1];
+                        if (ts.isObjectLiteralExpression(secondArg)) {
+                            for (const property of secondArg.properties) {
+                                if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && getNodeText(ts, property.name, ast) === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                                    required = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (node.arguments.length >= 1) {
+                        defineProp.push({
+                            name: _getStartEnd(node.arguments[0]),
+                            nameIsString: true,
+                            type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                            defaultValue: undefined,
+                            required,
+                        });
+                    }
+                    else if (ts.isVariableDeclaration(parent)) {
+                        defineProp.push({
+                            name: _getStartEnd(parent.name),
+                            nameIsString: false,
+                            type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                            defaultValue: undefined,
+                            required,
+                        });
+                    }
+                }
+                else if (definePropProposalB && ts.isVariableDeclaration(parent)) {
+                    defineProp.push({
+                        name: _getStartEnd(parent.name),
+                        nameIsString: false,
+                        defaultValue: node.arguments.length >= 1 ? _getStartEnd(node.arguments[0]) : undefined,
+                        type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                        required: node.arguments.length >= 2 && node.arguments[1].kind === ts.SyntaxKind.TrueKeyword,
+                    });
+                }
+            }
+            else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
+                slots.define = parseDefineFunction(node);
+                if (ts.isVariableDeclaration(parent)) {
+                    slots.name = getNodeText(ts, parent.name, ast);
+                }
+            }
+            else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
+                emits.define = parseDefineFunction(node);
+                if (ts.isVariableDeclaration(parent)) {
+                    emits.name = getNodeText(ts, parent.name, ast);
+                }
+            }
+            else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
+                expose.define = parseDefineFunction(node);
+            }
+            else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
+                let statementRange;
+                for (let i = parents.length - 1; i >= 0; i--) {
+                    if (ts.isStatement(parents[i])) {
+                        const statement = parents[i];
+                        ts.forEachChild(statement, child => {
+                            const range = _getStartEnd(child);
+                            statementRange ??= range;
+                            statementRange.end = range.end;
+                        });
+                        break;
+                    }
+                }
+                if (!statementRange) {
+                    statementRange = _getStartEnd(node);
+                }
+                props.define = {
+                    ...parseDefineFunction(node),
+                    statement: statementRange,
+                };
+                if (ts.isVariableDeclaration(parent)) {
+                    props.name = getNodeText(ts, parent.name, ast);
+                }
+                if (node.arguments.length) {
+                    props.define.arg = _getStartEnd(node.arguments[0]);
+                }
+                if (node.typeArguments?.length) {
+                    props.define.typeArg = _getStartEnd(node.typeArguments[0]);
+                }
+            }
+            else if (vueCompilerOptions.macros.withDefaults.includes(callText)) {
+                props.withDefaults = _getStartEnd(node);
+                if (node.arguments.length >= 2) {
+                    const arg = node.arguments[1];
+                    props.withDefaults.arg = _getStartEnd(arg);
+                }
+                if (ts.isVariableDeclaration(parent)) {
+                    props.name = getNodeText(ts, parent.name, ast);
+                }
+            }
+        }
+        ts.forEachChild(node, child => {
+            parents.push(node);
+            visitNode(child, parents);
+            parents.pop();
+        });
+    }
+}
+exports.parseScriptSetupRanges = parseScriptSetupRanges;
+function parseBindingRanges(ts, sourceFile) {
+    const bindings = [];
+    ts.forEachChild(sourceFile, node => {
+        if (ts.isVariableStatement(node)) {
+            for (const node_2 of node.declarationList.declarations) {
+                const vars = _findBindingVars(node_2.name);
+                for (const _var of vars) {
+                    bindings.push(_var);
+                }
+            }
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                bindings.push(_getStartEnd(node.name));
+            }
+        }
+        else if (ts.isClassDeclaration(node)) {
+            if (node.name) {
+                bindings.push(_getStartEnd(node.name));
+            }
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            bindings.push(_getStartEnd(node.name));
+        }
+        if (ts.isImportDeclaration(node)) {
+            if (node.importClause && !node.importClause.isTypeOnly) {
+                if (node.importClause.name) {
+                    bindings.push(_getStartEnd(node.importClause.name));
+                }
+                if (node.importClause.namedBindings) {
+                    if (ts.isNamedImports(node.importClause.namedBindings)) {
+                        for (const element of node.importClause.namedBindings.elements) {
+                            bindings.push(_getStartEnd(element.name));
+                        }
+                    }
+                    else if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+                        bindings.push(_getStartEnd(node.importClause.namedBindings.name));
+                    }
+                }
+            }
+        }
+    });
+    return bindings;
+    function _getStartEnd(node) {
+        return getStartEnd(ts, node, sourceFile);
+    }
+    function _findBindingVars(left) {
+        return findBindingVars(ts, left, sourceFile);
+    }
+}
+exports.parseBindingRanges = parseBindingRanges;
+function findBindingVars(ts, left, sourceFile) {
+    const vars = [];
+    worker(left);
+    return vars;
+    function worker(_node) {
+        if (ts.isIdentifier(_node)) {
+            vars.push(getStartEnd(ts, _node, sourceFile));
+        }
+        // { ? } = ...
+        // [ ? ] = ...
+        else if (ts.isObjectBindingPattern(_node) || ts.isArrayBindingPattern(_node)) {
+            for (const property of _node.elements) {
+                if (ts.isBindingElement(property)) {
+                    worker(property.name);
+                }
+            }
+        }
+        // { foo: ? } = ...
+        else if (ts.isPropertyAssignment(_node)) {
+            worker(_node.initializer);
+        }
+        // { foo } = ...
+        else if (ts.isShorthandPropertyAssignment(_node)) {
+            vars.push(getStartEnd(ts, _node.name, sourceFile));
+        }
+        // { ...? } = ...
+        // [ ...? ] = ...
+        else if (ts.isSpreadAssignment(_node) || ts.isSpreadElement(_node)) {
+            worker(_node.expression);
+        }
+    }
+}
+exports.findBindingVars = findBindingVars;
+function getStartEnd(ts, node, sourceFile) {
+    return {
+        start: ts.getTokenPosOfNode(node, sourceFile),
+        end: node.end,
+    };
+}
+exports.getStartEnd = getStartEnd;
+function getNodeText(ts, node, sourceFile) {
+    const { start, end } = getStartEnd(ts, node, sourceFile);
+    return sourceFile.text.substring(start, end);
+}
+exports.getNodeText = getNodeText;
+//# sourceMappingURL=scriptSetupRanges.js.map

package/lib/plugins/file-html.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;