@vue/language-core 2.0.0 → 2.0.2

package/lib/plugins/vue-tsx.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsCodegen = void 0;
+const language_core_1 = require("@volar/language-core");
+const computeds_1 = require("computeds");
+const script_1 = require("../generators/script");
+const template_1 = require("../generators/template");
+const utils_1 = require("../generators/utils");
+const scriptRanges_1 = require("../parsers/scriptRanges");
+const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
+exports.tsCodegen = new WeakMap();
+const plugin = (ctx) => {
+    return {
+        version: 2,
+        requiredCompilerOptions: [
+            'noPropertyAccessFromIndexSignature',
+            'exactOptionalPropertyTypes',
+        ],
+        getEmbeddedCodes(fileName, sfc) {
+            const tsx = useTsx(fileName, sfc);
+            const files = [];
+            if (['js', 'ts', 'jsx', 'tsx'].includes(tsx.lang())) {
+                files.push({ id: 'script_' + tsx.lang(), lang: tsx.lang() });
+            }
+            if (sfc.template) {
+                files.push({ id: 'template_format', lang: 'ts' });
+                files.push({ id: 'template_style', lang: 'css' });
+            }
+            return files;
+        },
+        resolveEmbeddedCode(fileName, sfc, embeddedFile) {
+            const _tsx = useTsx(fileName, sfc);
+            if (embeddedFile.id.startsWith('script_')) {
+                const tsx = _tsx.generatedScript();
+                if (tsx) {
+                    const [content, contentStacks] = ctx.codegenStack ? (0, language_core_1.track)([...tsx.codes], [...tsx.codeStacks]) : [[...tsx.codes], [...tsx.codeStacks]];
+                    content.forEach(code => {
+                        if (typeof code !== 'string') {
+                            code[3].structure = false;
+                            code[3].format = false;
+                        }
+                    });
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
+                    embeddedFile.linkedCodeMappings = [...tsx.linkedCodeMappings];
+                }
+            }
+            else if (embeddedFile.id === 'template_format') {
+                embeddedFile.parentCodeId = 'template';
+                const template = _tsx.generatedTemplate();
+                if (template) {
+                    const [content, contentStacks] = ctx.codegenStack
+                        ? (0, language_core_1.track)([...template.formatCodes], template.formatCodeStacks.map(stack => ({ stack, length: 1 })))
+                        : [[...template.formatCodes], template.formatCodeStacks.map(stack => ({ stack, length: 1 }))];
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
+                }
+                for (const style of sfc.styles) {
+                    embeddedFile.content.push('\n\n');
+                    for (const cssVar of style.cssVars) {
+                        embeddedFile.content.push('(');
+                        embeddedFile.content.push([
+                            cssVar.text,
+                            style.name,
+                            cssVar.offset,
+                            (0, utils_1.enableAllFeatures)({}),
+                        ]);
+                        embeddedFile.content.push(');\n');
+                    }
+                }
+            }
+            else if (embeddedFile.id === 'template_style') {
+                embeddedFile.parentCodeId = 'template';
+                const template = _tsx.generatedTemplate();
+                if (template) {
+                    const [content, contentStacks] = ctx.codegenStack
+                        ? (0, language_core_1.track)([...template.cssCodes], template.cssCodeStacks.map(stack => ({ stack, length: 1 })))
+                        : [[...template.cssCodes], template.cssCodeStacks.map(stack => ({ stack, length: 1 }))];
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
+                }
+            }
+        },
+    };
+    function useTsx(fileName, sfc) {
+        if (!exports.tsCodegen.has(sfc)) {
+            exports.tsCodegen.set(sfc, createTsx(fileName, sfc, ctx));
+        }
+        return exports.tsCodegen.get(sfc);
+    }
+};
+exports.default = plugin;
+function createTsx(fileName, _sfc, ctx) {
+    const ts = ctx.modules.typescript;
+    const lang = (0, computeds_1.computed)(() => {
+        return !_sfc.script && !_sfc.scriptSetup ? 'ts'
+            : _sfc.scriptSetup && _sfc.scriptSetup.lang !== 'js' ? _sfc.scriptSetup.lang
+                : _sfc.script && _sfc.script.lang !== 'js' ? _sfc.script.lang
+                    : 'js';
+    });
+    const scriptRanges = (0, computeds_1.computed)(() => _sfc.script
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.script.ast, !!_sfc.scriptSetup, false)
+        : undefined);
+    const scriptSetupRanges = (0, computeds_1.computed)(() => _sfc.scriptSetup
+        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, ctx.vueCompilerOptions)
+        : undefined);
+    const shouldGenerateScopedClasses = (0, computeds_1.computed)(() => {
+        const option = ctx.vueCompilerOptions.experimentalResolveStyleCssClasses;
+        return _sfc.styles.some(s => {
+            return option === 'always' || (option === 'scoped' && s.scoped);
+        });
+    });
+    const stylesScopedClasses = (0, computeds_1.computedSet)(() => {
+        const classes = new Set();
+        if (!shouldGenerateScopedClasses()) {
+            return classes;
+        }
+        for (const style of _sfc.styles) {
+            const option = ctx.vueCompilerOptions.experimentalResolveStyleCssClasses;
+            if (option === 'always' || (option === 'scoped' && style.scoped)) {
+                for (const className of style.classNames) {
+                    classes.add(className.text.substring(1));
+                }
+            }
+        }
+        return classes;
+    });
+    const generatedTemplate = (0, computeds_1.computed)(() => {
+        if (!_sfc.template)
+            return;
+        const tsCodes = [];
+        const tsFormatCodes = [];
+        const inlineCssCodes = [];
+        const tsCodegenStacks = [];
+        const tsFormatCodegenStacks = [];
+        const inlineCssCodegenStacks = [];
+        const codegen = (0, template_1.generate)(ts, ctx.compilerOptions, ctx.vueCompilerOptions, _sfc.template, shouldGenerateScopedClasses(), stylesScopedClasses(), hasScriptSetupSlots(), slotsAssignName(), propsAssignName(), ctx.codegenStack);
+        let current = codegen.next();
+        while (!current.done) {
+            const [type, code, stack] = current.value;
+            if (type === 'ts') {
+                tsCodes.push(code);
+            }
+            else if (type === 'tsFormat') {
+                tsFormatCodes.push(code);
+            }
+            else if (type === 'inlineCss') {
+                inlineCssCodes.push(code);
+            }
+            if (ctx.codegenStack) {
+                if (type === 'ts') {
+                    tsCodegenStacks.push(stack);
+                }
+                else if (type === 'tsFormat') {
+                    tsFormatCodegenStacks.push(stack);
+                }
+                else if (type === 'inlineCss') {
+                    inlineCssCodegenStacks.push(stack);
+                }
+            }
+            current = codegen.next();
+        }
+        return {
+            ...current.value,
+            codes: tsCodes,
+            codeStacks: tsCodegenStacks,
+            formatCodes: tsFormatCodes,
+            formatCodeStacks: tsFormatCodegenStacks,
+            cssCodes: inlineCssCodes,
+            cssCodeStacks: inlineCssCodegenStacks,
+        };
+    });
+    const hasScriptSetupSlots = (0, computeds_1.computed)(() => !!scriptSetupRanges()?.slots.define);
+    const slotsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.slots.name);
+    const propsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.props.name);
+    const generatedScript = (0, computeds_1.computed)(() => {
+        const codes = [];
+        const codeStacks = [];
+        const linkedCodeMappings = [];
+        const _template = generatedTemplate();
+        let generatedLength = 0;
+        for (const [code, stack] of (0, script_1.generate)(ts, fileName, _sfc.script, _sfc.scriptSetup, _sfc.styles, lang(), scriptRanges(), scriptSetupRanges(), _template ? {
+            tsCodes: _template.codes,
+            tsCodegenStacks: _template.codeStacks,
+            accessedGlobalVariables: _template.accessedGlobalVariables,
+            hasSlot: _template.hasSlot,
+            tagNames: new Set(_template.tagOffsetsMap.keys()),
+        } : undefined, ctx.compilerOptions, ctx.vueCompilerOptions, ctx.globalTypesHolder, () => generatedLength, linkedCodeMappings, ctx.codegenStack)) {
+            codes.push(code);
+            if (ctx.codegenStack) {
+                codeStacks.push({ stack, length: 1 });
+            }
+            generatedLength += typeof code === 'string'
+                ? code.length
+                : code[0].length;
+        }
+        ;
+        return {
+            codes,
+            codeStacks,
+            linkedCodeMappings,
+        };
+    });
+    return {
+        scriptRanges,
+        scriptSetupRanges,
+        lang,
+        generatedScript,
+        generatedTemplate,
+    };
+}
+//# sourceMappingURL=vue-tsx.js.map

package/lib/plugins.d.ts

@@ -0,0 +1,37 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type * as ts from 'typescript';
+import { type VueCompilerOptions, type VueLanguagePlugin } from './types';
+export declare function createPluginContext(ts: typeof import('typescript'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack: boolean, globalTypesHolder: string | undefined): {
+    modules: {
+        typescript: typeof import("typescript");
+        '@vue/compiler-dom': typeof CompilerDOM;
+    };
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    codegenStack: boolean;
+    globalTypesHolder: string | undefined;
+};
+export declare function getDefaultVueLanguagePlugins(pluginContext: Parameters<VueLanguagePlugin>[0]): {
+    version: 2;
+    name?: string | undefined;
+    order?: number | undefined;
+    requiredCompilerOptions?: string[] | undefined;
+    parseSFC?(fileName: string, content: string): import("@vue/compiler-sfc").SFCParseResult | undefined;
+    updateSFC?(oldResult: import("@vue/compiler-sfc").SFCParseResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): import("@vue/compiler-sfc").SFCParseResult | undefined;
+    resolveTemplateCompilerOptions?(options: CompilerDOM.CompilerOptions): CompilerDOM.CompilerOptions;
+    compileSFCTemplate?(lang: string, template: string, options: CompilerDOM.CompilerOptions): CompilerDOM.CodegenResult | undefined;
+    updateSFCTemplate?(oldResult: CompilerDOM.CodegenResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): CompilerDOM.CodegenResult | undefined;
+    getEmbeddedCodes?(fileName: string, sfc: import("./types").Sfc): {
+        id: string;
+        lang: string;
+    }[];
+    resolveEmbeddedCode?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./virtualFile/embeddedFile").VueEmbeddedCode): void;
+}[];

package/lib/plugins.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultVueLanguagePlugins = exports.createPluginContext = void 0;
+const CompilerDOM = require("@vue/compiler-dom");
+const file_html_1 = require("./plugins/file-html");
+const file_md_1 = require("./plugins/file-md");
+const file_vue_1 = require("./plugins/file-vue");
+const vue_sfc_customblocks_1 = require("./plugins/vue-sfc-customblocks");
+const vue_sfc_scripts_1 = require("./plugins/vue-sfc-scripts");
+const vue_sfc_styles_1 = require("./plugins/vue-sfc-styles");
+const vue_sfc_template_1 = require("./plugins/vue-sfc-template");
+const vue_template_html_1 = require("./plugins/vue-template-html");
+const vue_tsx_1 = require("./plugins/vue-tsx");
+const types_1 = require("./types");
+const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+function createPluginContext(ts, compilerOptions, vueCompilerOptions, codegenStack, globalTypesHolder) {
+    const pluginCtx = {
+        modules: {
+            '@vue/compiler-dom': vueCompilerOptions.target < 3
+                ? {
+                    ...CompilerDOM,
+                    compile: CompilerVue2.compile,
+                }
+                : CompilerDOM,
+            typescript: ts,
+        },
+        compilerOptions,
+        vueCompilerOptions,
+        codegenStack,
+        globalTypesHolder,
+    };
+    return pluginCtx;
+}
+exports.createPluginContext = createPluginContext;
+function getDefaultVueLanguagePlugins(pluginContext) {
+    const plugins = [
+        file_md_1.default, // .md for VitePress
+        file_html_1.default, // .html for PetiteVue
+        file_vue_1.default, // .vue and others for Vue
+        vue_template_html_1.default,
+        vue_sfc_styles_1.default,
+        vue_sfc_customblocks_1.default,
+        vue_sfc_scripts_1.default,
+        vue_sfc_template_1.default,
+        vue_tsx_1.default,
+        ...pluginContext.vueCompilerOptions.plugins,
+    ];
+    const pluginInstances = plugins
+        .map(plugin => plugin(pluginContext))
+        .sort((a, b) => {
+        const aOrder = a.order ?? 0;
+        const bOrder = b.order ?? 0;
+        return aOrder - bOrder;
+    });
+    return pluginInstances.filter((plugin) => {
+        const valid = plugin.version === types_1.pluginVersion;
+        if (!valid) {
+            console.warn(`Plugin ${JSON.stringify(plugin.name)} API version incompatible, expected ${JSON.stringify(types_1.pluginVersion)} but got ${JSON.stringify(plugin.version)}`);
+        }
+        return valid;
+    });
+}
+exports.getDefaultVueLanguagePlugins = getDefaultVueLanguagePlugins;
+//# sourceMappingURL=plugins.js.map

package/lib/types.d.ts

@@ -0,0 +1,142 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+import type { SFCParseResult } from '@vue/compiler-sfc';
+import type * as ts from 'typescript';
+import type { VueEmbeddedCode } from './virtualFile/embeddedFile';
+import type { CodeInformation, Segment } from '@volar/language-core';
+export type { SFCParseResult } from '@vue/compiler-sfc';
+export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
+    target?: 'auto' | 2 | 2.7 | 3 | 3.3;
+    plugins?: string[];
+};
+export interface VueCodeInformation extends CodeInformation {
+    __referencesCodeLens?: boolean;
+    __displayWithLink?: boolean;
+    __hint?: {
+        setting: string;
+        label: string;
+        tooltip: string;
+        paddingRight?: boolean;
+        paddingLeft?: boolean;
+    };
+    __combineLastMappping?: boolean;
+}
+export type CodeAndStack = [code: Code, stack: string];
+export type Code = Segment<VueCodeInformation>;
+export interface VueCompilerOptions {
+    target: number;
+    lib: string;
+    extensions: string[];
+    jsxSlots: boolean;
+    strictTemplates: boolean;
+    skipTemplateCodegen: boolean;
+    nativeTags: string[];
+    dataAttributes: string[];
+    htmlAttributes: string[];
+    optionsWrapper: [string, string] | [];
+    macros: {
+        defineProps: string[];
+        defineSlots: string[];
+        defineEmits: string[];
+        defineExpose: string[];
+        defineModel: string[];
+        defineOptions: string[];
+        withDefaults: string[];
+    };
+    plugins: VueLanguagePlugin[];
+    experimentalDefinePropProposal: 'kevinEdition' | 'johnsonEdition' | false;
+    experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
+    experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
+    experimentalUseElementAccessInTemplate: boolean;
+}
+export declare const pluginVersion = 2;
+export type VueLanguagePlugin = (ctx: {
+    modules: {
+        typescript: typeof import('typescript');
+        '@vue/compiler-dom': typeof import('@vue/compiler-dom');
+    };
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    codegenStack: boolean;
+    globalTypesHolder: string | undefined;
+}) => {
+    version: typeof pluginVersion;
+    name?: string;
+    order?: number;
+    requiredCompilerOptions?: string[];
+    parseSFC?(fileName: string, content: string): SFCParseResult | undefined;
+    updateSFC?(oldResult: SFCParseResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): SFCParseResult | undefined;
+    resolveTemplateCompilerOptions?(options: CompilerDOM.CompilerOptions): CompilerDOM.CompilerOptions;
+    compileSFCTemplate?(lang: string, template: string, options: CompilerDOM.CompilerOptions): CompilerDOM.CodegenResult | undefined;
+    updateSFCTemplate?(oldResult: CompilerDOM.CodegenResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): CompilerDOM.CodegenResult | undefined;
+    getEmbeddedCodes?(fileName: string, sfc: Sfc): {
+        id: string;
+        lang: string;
+    }[];
+    resolveEmbeddedCode?(fileName: string, sfc: Sfc, embeddedFile: VueEmbeddedCode): void;
+};
+export interface SfcBlock {
+    name: string;
+    start: number;
+    end: number;
+    startTagEnd: number;
+    endTagStart: number;
+    lang: string;
+    content: string;
+    attrs: Record<string, string | true>;
+}
+export interface Sfc {
+    template: SfcBlock & {
+        ast: CompilerDOM.RootNode | undefined;
+        errors: CompilerDOM.CompilerError[];
+        warnings: CompilerDOM.CompilerError[];
+    } | undefined;
+    script: (SfcBlock & {
+        src: string | undefined;
+        srcOffset: number;
+        ast: ts.SourceFile;
+    }) | undefined;
+    scriptSetup: SfcBlock & {
+        generic: string | undefined;
+        genericOffset: number;
+        ast: ts.SourceFile;
+    } | undefined;
+    styles: readonly (SfcBlock & {
+        module: string | undefined;
+        scoped: boolean;
+        cssVars: {
+            text: string;
+            offset: number;
+        }[];
+        classNames: {
+            text: string;
+            offset: number;
+        }[];
+    })[];
+    customBlocks: readonly (SfcBlock & {
+        type: string;
+    })[];
+    /**
+     * @deprecated use `template.ast` instead
+     */
+    templateAst: CompilerDOM.RootNode | undefined;
+    /**
+     * @deprecated use `script.ast` instead
+     */
+    scriptAst: ts.SourceFile | undefined;
+    /**
+     * @deprecated use `scriptSetup.ast` instead
+     */
+    scriptSetupAst: ts.SourceFile | undefined;
+}
+export interface TextRange {
+    start: number;
+    end: number;
+}

package/lib/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginVersion = void 0;
+exports.pluginVersion = 2;
+//# sourceMappingURL=types.js.map

package/lib/utils/parseCssClassNames.d.ts

@@ -0,0 +1,4 @@
+export declare function parseCssClassNames(styleContent: string): Generator<{
+    offset: number;
+    text: string;
+}, void, unknown>;

package/lib/utils/parseCssClassNames.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCssClassNames = void 0;
+const parseCssVars_1 = require("./parseCssVars");
+const cssClassNameReg = /(?=([\.]{1}[a-zA-Z_]+[\w\_\-]*)[\s\.\+\{\>#\:]{1})/g;
+function* parseCssClassNames(styleContent) {
+    styleContent = (0, parseCssVars_1.clearComments)(styleContent);
+    const matches = styleContent.matchAll(cssClassNameReg);
+    for (const match of matches) {
+        if (match.index !== undefined) {
+            const matchText = match[1];
+            if (matchText !== undefined) {
+                yield { offset: match.index, text: matchText };
+            }
+        }
+    }
+}
+exports.parseCssClassNames = parseCssClassNames;
+//# sourceMappingURL=parseCssClassNames.js.map

package/lib/utils/parseCssVars.d.ts

@@ -0,0 +1,5 @@
+export declare function parseCssVars(styleContent: string): Generator<{
+    offset: number;
+    text: string;
+}, void, unknown>;
+export declare function clearComments(css: string): string;

package/lib/utils/parseCssVars.js

@@ -0,0 +1,28 @@
+"use strict";
+// https://github.com/vuejs/core/blob/main/packages/compiler-sfc/src/cssVars.ts#L47-L61
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearComments = exports.parseCssVars = void 0;
+const vBindCssVarReg = /\bv-bind\(\s*(?:'([^']+)'|"([^"]+)"|([^'"][^)]*))\s*\)/g;
+const commentReg1 = /\/\*([\s\S]*?)\*\//g;
+const commentReg2 = /\/\/([\s\S]*?)\n/g;
+function* parseCssVars(styleContent) {
+    styleContent = clearComments(styleContent);
+    const matchs = styleContent.matchAll(vBindCssVarReg);
+    for (const match of matchs) {
+        if (match.index !== undefined) {
+            const matchText = match[1] ?? match[2] ?? match[3];
+            if (matchText !== undefined) {
+                const offset = match.index + styleContent.slice(match.index).indexOf(matchText);
+                yield { offset, text: matchText };
+            }
+        }
+    }
+}
+exports.parseCssVars = parseCssVars;
+function clearComments(css) {
+    return css
+        .replace(commentReg1, match => `/*${' '.repeat(match.length - 4)}*/`)
+        .replace(commentReg2, match => `//${' '.repeat(match.length - 3)}\n`);
+}
+exports.clearComments = clearComments;
+//# sourceMappingURL=parseCssVars.js.map

package/lib/utils/parseSfc.d.ts

@@ -0,0 +1,2 @@
+import type { SFCParseResult } from '@vue/compiler-sfc';
+export declare function parse(source: string): SFCParseResult;

package/lib/utils/parseSfc.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const compiler = require("@vue/compiler-dom");
+function parse(source) {
+    const errors = [];
+    const ast = compiler.parse(source, {
+        // there are no components at SFC parsing level
+        isNativeTag: () => true,
+        // preserve all whitespaces
+        isPreTag: () => true,
+        parseMode: 'sfc',
+        onError: e => {
+            errors.push(e);
+        },
+        comments: true,
+    });
+    const descriptor = {
+        filename: 'anonymous.vue',
+        source,
+        template: null,
+        script: null,
+        scriptSetup: null,
+        styles: [],
+        customBlocks: [],
+        cssVars: [],
+        slotted: false,
+        shouldForceReload: () => false,
+    };
+    ast.children.forEach(node => {
+        if (node.type !== compiler.NodeTypes.ELEMENT) {
+            return;
+        }
+        switch (node.tag) {
+            case 'template':
+                descriptor.template = createBlock(node, source);
+                break;
+            case 'script':
+                const scriptBlock = createBlock(node, source);
+                const isSetup = !!scriptBlock.attrs.setup;
+                if (isSetup && !descriptor.scriptSetup) {
+                    descriptor.scriptSetup = scriptBlock;
+                    break;
+                }
+                if (!isSetup && !descriptor.script) {
+                    descriptor.script = scriptBlock;
+                    break;
+                }
+                break;
+            case 'style':
+                const styleBlock = createBlock(node, source);
+                descriptor.styles.push(styleBlock);
+                break;
+            default:
+                descriptor.customBlocks.push(createBlock(node, source));
+                break;
+        }
+    });
+    return {
+        descriptor,
+        errors,
+    };
+}
+exports.parse = parse;
+function createBlock(node, source) {
+    const type = node.tag;
+    let { start, end } = node.loc;
+    let content = '';
+    if (node.children.length) {
+        start = node.children[0].loc.start;
+        end = node.children[node.children.length - 1].loc.end;
+        content = source.slice(start.offset, end.offset);
+    }
+    else {
+        const offset = node.loc.source.indexOf(`</`);
+        if (offset > -1) {
+            start = {
+                line: start.line,
+                column: start.column + offset,
+                offset: start.offset + offset
+            };
+        }
+        end = Object.assign({}, start);
+    }
+    const loc = {
+        source: content,
+        start,
+        end
+    };
+    const attrs = {};
+    const block = {
+        type,
+        content,
+        loc,
+        attrs
+    };
+    node.props.forEach(p => {
+        if (p.type === compiler.NodeTypes.ATTRIBUTE) {
+            attrs[p.name] = p.value ? p.value.content || true : true;
+            if (p.name === 'lang') {
+                block.lang = p.value && p.value.content;
+            }
+            else if (p.name === 'src') {
+                block.src = p.value && p.value.content;
+            }
+            else if (type === 'style') {
+                if (p.name === 'scoped') {
+                    block.scoped = true;
+                }
+                else if (p.name === 'module') {
+                    block.module = attrs[p.name];
+                }
+            }
+            else if (type === 'script' && p.name === 'setup') {
+                block.setup = attrs.setup;
+            }
+        }
+    });
+    return block;
+}
+//# sourceMappingURL=parseSfc.js.map

package/lib/utils/shared.d.ts

@@ -0,0 +1,3 @@
+export declare function getSlotsPropertyName(vueVersion: number): "$scopedSlots" | "$slots";
+export { hyphenate as hyphenateTag } from '@vue/shared';
+export declare function hyphenateAttr(str: string): string;

package/lib/utils/shared.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hyphenateAttr = exports.hyphenateTag = exports.getSlotsPropertyName = void 0;
+const shared_1 = require("@vue/shared");
+function getSlotsPropertyName(vueVersion) {
+    return vueVersion < 3 ? '$scopedSlots' : '$slots';
+}
+exports.getSlotsPropertyName = getSlotsPropertyName;
+var shared_2 = require("@vue/shared");
+Object.defineProperty(exports, "hyphenateTag", { enumerable: true, get: function () { return shared_2.hyphenate; } });
+function hyphenateAttr(str) {
+    let hyphencase = (0, shared_1.hyphenate)(str);
+    // fix https://github.com/vuejs/core/issues/8811
+    if (str.length && str[0] !== str[0].toLowerCase()) {
+        hyphencase = '-' + hyphencase;
+    }
+    return hyphencase;
+}
+exports.hyphenateAttr = hyphenateAttr;
+//# sourceMappingURL=shared.js.map