@vue/language-core 1.7.0

package/out/index.d.ts

@@ -0,0 +1,12 @@
+export * from './generators/template';
+export * from './languageModule';
+export * from './parsers/scriptSetupRanges';
+export * from './plugins';
+export * from './sourceFile';
+export * from './types';
+export * from './utils/ts';
+export * from './utils/parseSfc';
+export * as scriptRanges from './parsers/scriptRanges';
+export * as sharedTypes from './utils/directorySharedTypes';
+export * from '@volar/language-core';
+export * from '@volar/source-map';

package/out/index.js

@@ -0,0 +1,30 @@
+"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 });
+exports.sharedTypes = exports.scriptRanges = void 0;
+__exportStar(require("./generators/template"), exports);
+__exportStar(require("./languageModule"), exports);
+__exportStar(require("./parsers/scriptSetupRanges"), exports);
+__exportStar(require("./plugins"), exports);
+__exportStar(require("./sourceFile"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils/ts"), exports);
+__exportStar(require("./utils/parseSfc"), exports);
+exports.scriptRanges = require("./parsers/scriptRanges");
+exports.sharedTypes = require("./utils/directorySharedTypes");
+__exportStar(require("@volar/language-core"), exports);
+__exportStar(require("@volar/source-map"), exports);
+//# sourceMappingURL=index.js.map

package/out/languageModule.d.ts

@@ -0,0 +1,5 @@
+import type { Language } from '@volar/language-core';
+import { VueCompilerOptions } from './types';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function createLanguage(compilerOptions?: ts.CompilerOptions, vueCompilerOptions?: VueCompilerOptions, ts?: typeof import('typescript/lib/tsserverlibrary')): Language;
+export declare function createLanguages(compilerOptions?: ts.CompilerOptions, vueCompilerOptions?: VueCompilerOptions, ts?: typeof import('typescript/lib/tsserverlibrary')): Language[];

package/out/languageModule.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguages = exports.createLanguage = void 0;
+const path_1 = require("path");
+const plugins_1 = require("./plugins");
+const sourceFile_1 = require("./sourceFile");
+const sharedTypes = require("./utils/directorySharedTypes");
+const ts_1 = require("./utils/ts");
+function createLanguage(compilerOptions = {}, vueCompilerOptions = (0, ts_1.resolveVueCompilerOptions)({}), ts = require('typescript')) {
+    patchResolveModuleNames(ts, vueCompilerOptions);
+    const vueLanguagePlugin = (0, plugins_1.getDefaultVueLanguagePlugins)(ts, compilerOptions, vueCompilerOptions);
+    const sharedTypesSnapshot = ts.ScriptSnapshot.fromString(sharedTypes.getTypesCode(vueCompilerOptions));
+    const languageModule = {
+        createVirtualFile(fileName, snapshot, languageId) {
+            if (languageId === 'vue'
+                || (!languageId
+                    && vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext)))) {
+                return new sourceFile_1.VueFile(fileName, snapshot, ts, vueLanguagePlugin);
+            }
+        },
+        updateVirtualFile(sourceFile, snapshot) {
+            sourceFile.update(snapshot);
+        },
+        resolveHost(host) {
+            return {
+                ...host,
+                fileExists(fileName) {
+                    const basename = path_1.posix.basename(fileName);
+                    if (basename === sharedTypes.baseName) {
+                        return true;
+                    }
+                    return host.fileExists(fileName);
+                },
+                getScriptFileNames() {
+                    const fileNames = host.getScriptFileNames();
+                    return [
+                        ...getSharedTypesFiles(fileNames),
+                        ...fileNames,
+                    ];
+                },
+                getScriptVersion(fileName) {
+                    const basename = path_1.posix.basename(fileName);
+                    if (basename === sharedTypes.baseName) {
+                        return '';
+                    }
+                    return host.getScriptVersion(fileName);
+                },
+                getScriptSnapshot(fileName) {
+                    const basename = path_1.posix.basename(fileName);
+                    if (basename === sharedTypes.baseName) {
+                        return sharedTypesSnapshot;
+                    }
+                    return host.getScriptSnapshot(fileName);
+                },
+            };
+        },
+    };
+    return languageModule;
+    function getSharedTypesFiles(fileNames) {
+        const moduleFiles = fileNames.filter(fileName => vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext)));
+        const moduleFileDirs = [...new Set(moduleFiles.map(path_1.posix.dirname))];
+        return moduleFileDirs.map(dir => path_1.posix.join(dir, sharedTypes.baseName));
+    }
+}
+exports.createLanguage = createLanguage;
+function createLanguages(compilerOptions = {}, vueCompilerOptions = (0, ts_1.resolveVueCompilerOptions)({}), ts = require('typescript')) {
+    return [
+        createLanguage(compilerOptions, vueCompilerOptions, ts),
+        ...vueCompilerOptions.experimentalAdditionalLanguageModules?.map(module => require(module)) ?? [],
+    ];
+}
+exports.createLanguages = createLanguages;
+function patchResolveModuleNames(ts, vueCompilerOptions) {
+    try {
+        // from https://github.com/vuejs/language-tools/pull/1543
+        if (!(ts.__vuePatchResolveModuleNames)) {
+            ts.__vuePatchResolveModuleNames = true;
+            const resolveModuleNames = ts.resolveModuleName;
+            ts.resolveModuleName = (...args) => {
+                if (args[6] === ts.ModuleKind.ESNext && vueCompilerOptions.extensions.some(ext => args[0].endsWith(ext))) {
+                    args[6] = ts.ModuleKind.CommonJS;
+                }
+                return resolveModuleNames(...args);
+            };
+        }
+    }
+    catch (e) {
+        // console.warn('[volar] patchResolveModuleNames failed', e);
+    }
+}
+//# sourceMappingURL=languageModule.js.map

package/out/parsers/scriptRanges.d.ts

@@ -0,0 +1,15 @@
+import type { TextRange } from '../types';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
+}
+export declare function parseScriptRanges(ts: typeof import('typescript/lib/tsserverlibrary'), 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/out/parsers/scriptRanges.js

@@ -0,0 +1,58 @@
+"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, false) : [];
+    ast.forEachChild(raw => {
+        if (ts.isExportAssignment(raw)) {
+            let node = raw;
+            while (ts.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;
+                obj.forEachChild(node => {
+                    if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
+                        if (node.name.escapedText === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
+                            componentsOptionNode = node.initializer;
+                        }
+                        if (node.name.escapedText === '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)(node, ast);
+    }
+}
+exports.parseScriptRanges = parseScriptRanges;
+//# sourceMappingURL=scriptRanges.js.map

package/out/parsers/scriptSetupRanges.d.ts

@@ -0,0 +1,32 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type { VueCompilerOptions, TextRange } from '../types';
+export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRanges> {
+}
+export declare function parseScriptSetupRanges(ts: typeof import('typescript/lib/tsserverlibrary'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
+    importSectionEndOffset: number;
+    bindings: TextRange[];
+    withDefaultsArg: TextRange | undefined;
+    defineProps: TextRange | undefined;
+    propsAssignName: string | undefined;
+    propsRuntimeArg: TextRange | undefined;
+    propsTypeArg: TextRange | undefined;
+    slotsTypeArg: TextRange | undefined;
+    emitsAssignName: string | undefined;
+    emitsRuntimeArg: TextRange | undefined;
+    emitsTypeArg: TextRange | undefined;
+    emitsTypeNums: number;
+    exposeRuntimeArg: TextRange | undefined;
+    defineProp: {
+        name: TextRange | undefined;
+        nameIsString: boolean;
+        type: TextRange | undefined;
+        defaultValue: TextRange | undefined;
+        required: boolean;
+    }[];
+};
+export declare function parseBindingRanges(ts: typeof import('typescript/lib/tsserverlibrary'), sourceFile: ts.SourceFile, isType: boolean): TextRange[];
+export declare function findBindingVars(ts: typeof import('typescript/lib/tsserverlibrary'), left: ts.BindingName, sourceFile: ts.SourceFile): TextRange[];
+export declare function getStartEnd(node: ts.Node, sourceFile: ts.SourceFile): {
+    start: number;
+    end: number;
+};

package/out/parsers/scriptSetupRanges.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStartEnd = exports.findBindingVars = exports.parseBindingRanges = exports.parseScriptSetupRanges = void 0;
+function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
+    let foundNonImportExportNode = false;
+    let importSectionEndOffset = 0;
+    let withDefaultsArg;
+    let propsAssignName;
+    let defineProps;
+    let propsRuntimeArg;
+    let propsTypeArg;
+    let slotsTypeArg;
+    let emitsAssignName;
+    let emitsRuntimeArg;
+    let emitsTypeArg;
+    let exposeRuntimeArg;
+    let emitsTypeNums = -1;
+    const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition' || ast.getFullText().trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition');
+    const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition' || ast.getFullText().trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition');
+    const defineProp = [];
+    const bindings = parseBindingRanges(ts, ast, false);
+    ast.forEachChild(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)) {
+            importSectionEndOffset = node.getStart(ast, true);
+            foundNonImportExportNode = true;
+        }
+    });
+    ast.forEachChild(child => visitNode(child, ast));
+    return {
+        importSectionEndOffset,
+        bindings,
+        withDefaultsArg,
+        defineProps,
+        propsAssignName,
+        propsRuntimeArg,
+        propsTypeArg,
+        slotsTypeArg,
+        emitsAssignName,
+        emitsRuntimeArg,
+        emitsTypeArg,
+        emitsTypeNums,
+        exposeRuntimeArg,
+        defineProp,
+    };
+    function _getStartEnd(node) {
+        return getStartEnd(node, ast);
+    }
+    function visitNode(node, parent) {
+        if (ts.isCallExpression(node)
+            && ts.isIdentifier(node.expression)) {
+            const callText = node.expression.getText(ast);
+            if (callText === 'defineModel') {
+                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) && property.name.getText(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,
+                });
+            }
+            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) && property.name.getText(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,
+                    });
+                }
+            }
+            if (vueCompilerOptions.macros.defineProps.includes(callText)
+                || vueCompilerOptions.macros.defineSlots.includes(callText)
+                || vueCompilerOptions.macros.defineEmits.includes(callText)
+                || vueCompilerOptions.macros.defineExpose.includes(callText)) {
+                if (vueCompilerOptions.macros.defineProps.includes(callText)) {
+                    defineProps = _getStartEnd(node);
+                }
+                if (node.arguments.length) {
+                    const runtimeArg = node.arguments[0];
+                    if (vueCompilerOptions.macros.defineProps.includes(callText)) {
+                        propsRuntimeArg = _getStartEnd(runtimeArg);
+                        if (ts.isVariableDeclaration(parent)) {
+                            propsAssignName = parent.name.getText(ast);
+                        }
+                    }
+                    else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
+                        emitsRuntimeArg = _getStartEnd(runtimeArg);
+                        if (ts.isVariableDeclaration(parent)) {
+                            emitsAssignName = parent.name.getText(ast);
+                        }
+                    }
+                    else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
+                        exposeRuntimeArg = _getStartEnd(runtimeArg);
+                    }
+                }
+                if (node.typeArguments?.length) {
+                    const typeArg = node.typeArguments[0];
+                    if (vueCompilerOptions.macros.defineProps.includes(callText)) {
+                        propsTypeArg = _getStartEnd(typeArg);
+                        if (ts.isVariableDeclaration(parent)) {
+                            propsAssignName = parent.name.getText(ast);
+                        }
+                    }
+                    if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
+                        slotsTypeArg = _getStartEnd(typeArg);
+                    }
+                    else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
+                        emitsTypeArg = _getStartEnd(typeArg);
+                        if (ts.isTypeLiteralNode(typeArg)) {
+                            emitsTypeNums = typeArg.members.length;
+                        }
+                        if (ts.isVariableDeclaration(parent)) {
+                            emitsAssignName = parent.name.getText(ast);
+                        }
+                    }
+                }
+            }
+            else if (vueCompilerOptions.macros.withDefaults.includes(callText)) {
+                if (node.arguments.length >= 2) {
+                    const arg = node.arguments[1];
+                    withDefaultsArg = _getStartEnd(arg);
+                }
+                if (ts.isVariableDeclaration(parent)) {
+                    propsAssignName = parent.name.getText(ast);
+                }
+            }
+        }
+        node.forEachChild(child => visitNode(child, node));
+    }
+}
+exports.parseScriptSetupRanges = parseScriptSetupRanges;
+function parseBindingRanges(ts, sourceFile, isType) {
+    const bindings = [];
+    sourceFile.forEachChild(node => {
+        if (!isType) {
+            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));
+            }
+        }
+        else {
+            if (ts.isTypeAliasDeclaration(node)) {
+                bindings.push(_getStartEnd(node.name));
+            }
+            else if (ts.isInterfaceDeclaration(node)) {
+                bindings.push(_getStartEnd(node.name));
+            }
+        }
+        if (ts.isImportDeclaration(node)) {
+            if (node.importClause && (isType || !node.importClause.isTypeOnly)) {
+                if (node.importClause.name && !isType) {
+                    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(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(_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(_node.name, sourceFile));
+        }
+        // { ...? } = ...
+        // [ ...? ] = ...
+        else if (ts.isSpreadAssignment(_node) || ts.isSpreadElement(_node)) {
+            worker(_node.expression);
+        }
+    }
+}
+exports.findBindingVars = findBindingVars;
+function getStartEnd(node, sourceFile) {
+    return {
+        start: node.getStart(sourceFile),
+        end: node.getEnd(),
+    };
+}
+exports.getStartEnd = getStartEnd;
+//# sourceMappingURL=scriptSetupRanges.js.map

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

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

package/out/plugins/file-html.js

@@ -0,0 +1,80 @@
+"use strict";
+const plugin = () => {
+    return {
+        version: 1,
+        parseSFC(fileName, content) {
+            if (fileName.endsWith('.html')) {
+                let sfc = {
+                    descriptor: {
+                        filename: fileName,
+                        source: content,
+                        template: null,
+                        script: null,
+                        scriptSetup: null,
+                        styles: [],
+                        customBlocks: [],
+                        cssVars: [],
+                        shouldForceReload: () => false,
+                        slotted: false,
+                    },
+                    errors: [],
+                };
+                let templateContent = content;
+                const sfcBlockReg = /\<(script|style)\b([\s\S]*?)\>([\s\S]*?)\<\/\1\>/g;
+                const langReg = /\blang\s*=\s*(['\"]?)(\S*)\b\1/;
+                for (const match of content.matchAll(sfcBlockReg)) {
+                    const matchText = match[0];
+                    const tag = match[1];
+                    const attrs = match[2];
+                    const lang = attrs.match(langReg)?.[2];
+                    const content = match[3];
+                    const contentStart = match.index + matchText.indexOf(content);
+                    if (tag === 'style') {
+                        sfc.descriptor.styles.push({
+                            attrs: {},
+                            content,
+                            loc: {
+                                start: { column: -1, line: -1, offset: contentStart },
+                                end: { column: -1, line: -1, offset: contentStart + content.length },
+                                source: content,
+                            },
+                            type: 'style',
+                            lang,
+                        });
+                    }
+                    // ignore `<script src="...">`
+                    else if (tag === 'script' && attrs.indexOf('src=') === -1) {
+                        let type = attrs.indexOf('type=') >= 0 ? 'scriptSetup' : 'script';
+                        sfc.descriptor[type] = {
+                            attrs: {},
+                            content,
+                            loc: {
+                                start: { column: -1, line: -1, offset: contentStart },
+                                end: { column: -1, line: -1, offset: contentStart + content.length },
+                                source: content,
+                            },
+                            type: 'script',
+                            lang,
+                        };
+                    }
+                    templateContent = templateContent.substring(0, match.index) + ' '.repeat(matchText.length) + templateContent.substring(match.index + matchText.length);
+                }
+                sfc.descriptor.template = {
+                    attrs: {},
+                    content: templateContent,
+                    loc: {
+                        start: { column: -1, line: -1, offset: 0 },
+                        end: { column: -1, line: -1, offset: templateContent.length },
+                        source: templateContent,
+                    },
+                    type: 'template',
+                    ast: {},
+                };
+                return sfc;
+            }
+            ;
+        }
+    };
+};
+module.exports = plugin;
+//# sourceMappingURL=file-html.js.map

package/out/plugins/file-md.d.ts

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