@vue/language-core 1.9.0-alpha.3 → 2.0.0

package/out/index.d.ts

@@ -1,16 +0,0 @@
-export * from './generators/template';
-export * from './languageModule';
-export * from './parsers/scriptSetupRanges';
-export * from './plugins';
-export * from './virtualFile/vueFile';
-export * from './types';
-export * from './utils/ts';
-export * from './utils/parseSfc';
-export * as scriptRanges from './parsers/scriptRanges';
-export * as sharedTypes from './utils/globalTypes';
-export * from './utils/shared';
-export { tsCodegen } from './plugins/vue-tsx';
-export * from '@volar/language-core';
-export * from '@volar/source-map';
-export type * as CompilerDOM from '@vue/compiler-dom';
-//# sourceMappingURL=index.d.ts.map

package/out/index.js

@@ -1,33 +0,0 @@
-"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.tsCodegen = 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("./virtualFile/vueFile"), exports);
-__exportStar(require("./types"), exports);
-__exportStar(require("./utils/ts"), exports);
-__exportStar(require("./utils/parseSfc"), exports);
-exports.scriptRanges = require("./parsers/scriptRanges");
-exports.sharedTypes = require("./utils/globalTypes");
-__exportStar(require("./utils/shared"), exports);
-var vue_tsx_1 = require("./plugins/vue-tsx");
-Object.defineProperty(exports, "tsCodegen", { enumerable: true, get: function () { return vue_tsx_1.tsCodegen; } });
-__exportStar(require("@volar/language-core"), exports);
-__exportStar(require("@volar/source-map"), exports);
-//# sourceMappingURL=index.js.map

package/out/languageModule.d.ts

@@ -1,10 +0,0 @@
-import type { Language } from '@volar/language-core';
-import { VueFile } from './virtualFile/vueFile';
-import { VueCompilerOptions } from './types';
-import type * as ts from 'typescript/lib/tsserverlibrary';
-export declare function createVueLanguage(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions?: ts.CompilerOptions, _vueCompilerOptions?: Partial<VueCompilerOptions>, codegenStack?: boolean): Language<VueFile>;
-/**
- * @deprecated planed to remove in 2.0, please use createVueLanguage instead of
- */
-export declare function createLanguages(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions?: ts.CompilerOptions, vueCompilerOptions?: Partial<VueCompilerOptions>, codegenStack?: boolean): Language[];
-//# sourceMappingURL=languageModule.d.ts.map

package/out/languageModule.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLanguages = exports.createVueLanguage = void 0;
-const path = require("path-browserify");
-const plugins_1 = require("./plugins");
-const vueFile_1 = require("./virtualFile/vueFile");
-const sharedTypes = require("./utils/globalTypes");
-const ts_1 = require("./utils/ts");
-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 createVueLanguage(ts, compilerOptions = {}, _vueCompilerOptions = {}, codegenStack = false) {
-    const vueCompilerOptions = (0, ts_1.resolveVueCompilerOptions)(_vueCompilerOptions);
-    const plugins = (0, plugins_1.getDefaultVueLanguagePlugins)(ts, compilerOptions, vueCompilerOptions, codegenStack);
-    const keys = [
-        ...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]]),
-    ];
-    const fileRegistry = getVueFileRegistry(JSON.stringify(keys), _vueCompilerOptions.plugins ?? []);
-    const allowLanguageIds = new Set(['vue']);
-    if (vueCompilerOptions.extensions.includes('.md')) {
-        allowLanguageIds.add('markdown');
-    }
-    if (vueCompilerOptions.extensions.includes('.html')) {
-        allowLanguageIds.add('html');
-    }
-    return {
-        createVirtualFile(fileName, snapshot, languageId) {
-            if ((languageId && allowLanguageIds.has(languageId))
-                || (!languageId && vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext)))) {
-                if (fileRegistry.has(fileName)) {
-                    const reusedVueFile = fileRegistry.get(fileName);
-                    reusedVueFile.update(snapshot);
-                    return reusedVueFile;
-                }
-                const vueFile = new vueFile_1.VueFile(fileName, snapshot, vueCompilerOptions, plugins, ts, codegenStack);
-                fileRegistry.set(fileName, vueFile);
-                return vueFile;
-            }
-        },
-        updateVirtualFile(sourceFile, snapshot) {
-            sourceFile.update(snapshot);
-        },
-        resolveHost(host) {
-            const sharedTypesSnapshot = ts.ScriptSnapshot.fromString(sharedTypes.getTypesCode(vueCompilerOptions));
-            const sharedTypesFileName = path.join(host.rootPath, sharedTypes.baseName);
-            return {
-                ...host,
-                resolveModuleName(moduleName, impliedNodeFormat) {
-                    if (impliedNodeFormat === ts.ModuleKind.ESNext && vueCompilerOptions.extensions.some(ext => moduleName.endsWith(ext))) {
-                        return `${moduleName}.js`;
-                    }
-                    return host.resolveModuleName?.(moduleName, impliedNodeFormat) ?? moduleName;
-                },
-                getScriptFileNames() {
-                    return [
-                        sharedTypesFileName,
-                        ...host.getScriptFileNames(),
-                    ];
-                },
-                getScriptSnapshot(fileName) {
-                    if (fileName === sharedTypesFileName) {
-                        return sharedTypesSnapshot;
-                    }
-                    return host.getScriptSnapshot(fileName);
-                },
-            };
-        },
-    };
-}
-exports.createVueLanguage = createVueLanguage;
-/**
- * @deprecated planed to remove in 2.0, please use createVueLanguage instead of
- */
-function createLanguages(ts, compilerOptions = {}, vueCompilerOptions = {}, codegenStack = false) {
-    return [
-        createVueLanguage(ts, compilerOptions, vueCompilerOptions, codegenStack),
-        ...vueCompilerOptions.experimentalAdditionalLanguageModules?.map(module => require(module)) ?? [],
-    ];
-}
-exports.createLanguages = createLanguages;
-//# sourceMappingURL=languageModule.js.map

package/out/parsers/scriptRanges.d.ts

@@ -1,16 +0,0 @@
-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[];
-};
-//# sourceMappingURL=scriptRanges.d.ts.map

package/out/parsers/scriptRanges.js

@@ -1,58 +0,0 @@
-"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) : [];
-    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

@@ -1,49 +0,0 @@
-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): {
-    leadingCommentEndOffset: number;
-    importSectionEndOffset: number;
-    bindings: TextRange[];
-    props: {
-        name?: string | undefined;
-        define?: (TextRange & {
-            statement: TextRange;
-            arg?: TextRange | undefined;
-            typeArg?: TextRange | undefined;
-        }) | undefined;
-        withDefaults?: (TextRange & {
-            arg?: TextRange | undefined;
-        }) | undefined;
-    };
-    slots: {
-        name?: string | undefined;
-        define?: TextRange | undefined;
-    };
-    emits: {
-        name?: string | undefined;
-        define?: TextRange | 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;
-    }[];
-};
-export declare function parseBindingRanges(ts: typeof import('typescript/lib/tsserverlibrary'), sourceFile: ts.SourceFile): 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;
-};
-//# sourceMappingURL=scriptSetupRanges.d.ts.map

package/out/parsers/scriptSetupRanges.js

@@ -1,291 +0,0 @@
-"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;
-    const props = {};
-    const slots = {};
-    const emits = {};
-    const expose = {};
-    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);
-    const text = ast.getFullText();
-    const leadingCommentEndOffset = ts.getLeadingCommentRanges(text, 0)?.reverse()[0].end ?? 0;
-    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)) {
-            const commentRanges = ts.getLeadingCommentRanges(text, node.getFullStart());
-            if (commentRanges?.length) {
-                const commentRange = commentRanges.sort((a, b) => a.pos - b.pos)[0];
-                importSectionEndOffset = commentRange.pos;
-            }
-            else {
-                importSectionEndOffset = node.getStart(ast);
-            }
-            foundNonImportExportNode = true;
-        }
-    });
-    ast.forEachChild(child => visitNode(child, [ast]));
-    return {
-        leadingCommentEndOffset,
-        importSectionEndOffset,
-        bindings,
-        props,
-        slots,
-        emits,
-        expose,
-        defineProp,
-    };
-    function _getStartEnd(node) {
-        return getStartEnd(node, ast);
-    }
-    function visitNode(node, parents) {
-        const parent = parents[parents.length - 1];
-        if (ts.isCallExpression(node)
-            && ts.isIdentifier(node.expression)) {
-            const callText = node.expression.getText(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) && 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,
-                    });
-                }
-            }
-            else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
-                slots.define = _getStartEnd(node);
-                if (ts.isVariableDeclaration(parent)) {
-                    slots.name = parent.name.getText(ast);
-                }
-            }
-            else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
-                emits.define = _getStartEnd(node);
-                if (ts.isVariableDeclaration(parent)) {
-                    emits.name = parent.name.getText(ast);
-                }
-            }
-            else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
-                expose.define = _getStartEnd(node);
-                if (node.arguments.length) {
-                    expose.define.arg = _getStartEnd(node.arguments[0]);
-                }
-                if (node.typeArguments?.length) {
-                    expose.define.typeArg = _getStartEnd(node.typeArguments[0]);
-                }
-            }
-            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];
-                        statement.forEachChild(child => {
-                            const range = _getStartEnd(child);
-                            statementRange ??= range;
-                            statementRange.end = range.end;
-                        });
-                        break;
-                    }
-                }
-                if (!statementRange) {
-                    statementRange = _getStartEnd(node);
-                }
-                props.define = {
-                    ..._getStartEnd(node),
-                    statement: statementRange,
-                };
-                if (ts.isVariableDeclaration(parent)) {
-                    props.name = parent.name.getText(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 = parent.name.getText(ast);
-                }
-            }
-        }
-        node.forEachChild(child => {
-            parents.push(node);
-            visitNode(child, parents);
-            parents.pop();
-        });
-    }
-}
-exports.parseScriptSetupRanges = parseScriptSetupRanges;
-function parseBindingRanges(ts, sourceFile) {
-    const bindings = [];
-    sourceFile.forEachChild(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(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

@@ -1,4 +0,0 @@
-import { VueLanguagePlugin } from '../types';
-declare const plugin: VueLanguagePlugin;
-export default plugin;
-//# sourceMappingURL=file-html.d.ts.map

package/out/plugins/file-html.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sfcBlockReg = /\<(script|style)\b([\s\S]*?)\>([\s\S]*?)\<\/\1\>/g;
-const langReg = /\blang\s*=\s*(['\"]?)(\S*)\b\1/;
-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;
-                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;
-            }
-            ;
-        }
-    };
-};
-exports.default = plugin;
-//# sourceMappingURL=file-html.js.map

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

@@ -1,4 +0,0 @@
-import { VueLanguagePlugin } from '../types';
-declare const plugin: VueLanguagePlugin;
-export default plugin;
-//# sourceMappingURL=file-md.d.ts.map