@vue/language-core 2.0.29 → 2.1.0

package/lib/parsers/scriptSetupRanges.js

@@ -5,6 +5,7 @@ exports.parseBindingRanges = parseBindingRanges;
 exports.findBindingVars = findBindingVars;
 exports.getStartEnd = getStartEnd;
 exports.getNodeText = getNodeText;
+const common_1 = require("../codegen/common");
 function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     let foundNonImportExportNode = false;
     let importSectionEndOffset = 0;
@@ -13,6 +14,8 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const emits = {};
     const expose = {};
     const options = {};
+    const cssModules = [];
+    const templateRefs = [];
     const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition' || ast.text.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition');
     const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition' || ast.text.trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition');
     const defineProp = [];
@@ -57,8 +60,10 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         slots,
         emits,
         expose,
-        defineProp,
         options,
+        cssModules,
+        defineProp,
+        templateRefs,
     };
     function _getStartEnd(node) {
         return getStartEnd(ts, node, ast);
@@ -76,81 +81,124 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             && ts.isIdentifier(node.expression)) {
             const callText = getNodeText(ts, node.expression, ast);
             if (vueCompilerOptions.macros.defineModel.includes(callText)) {
-                let name;
+                let localName;
+                let propName;
                 let options;
+                if (ts.isVariableDeclaration(parent) &&
+                    ts.isIdentifier(parent.name)) {
+                    localName = _getStartEnd(parent.name);
+                }
                 if (node.arguments.length >= 2) {
-                    name = _getStartEnd(node.arguments[0]);
+                    propName = _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]);
+                        propName = _getStartEnd(node.arguments[0]);
                     }
                     else {
                         options = node.arguments[0];
                     }
                 }
+                let runtimeType;
+                let defaultValue;
                 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) {
+                        if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+                            continue;
+                        }
+                        const text = getNodeText(ts, property.name, ast);
+                        if (text === 'type') {
+                            runtimeType = _getStartEnd(property.initializer);
+                        }
+                        else if (text === 'default') {
+                            defaultValue = _getStartEnd(property.initializer);
+                        }
+                        else if (text === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
                             required = true;
-                            break;
                         }
                     }
                 }
                 defineProp.push({
-                    name,
-                    nameIsString: true,
+                    localName,
+                    name: propName,
                     type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
                     modifierType: node.typeArguments && node.typeArguments?.length >= 2 ? _getStartEnd(node.typeArguments[1]) : undefined,
-                    defaultValue: undefined,
+                    runtimeType,
+                    defaultValue,
                     required,
                     isModel: true,
                 });
             }
             else if (callText === 'defineProp') {
+                let localName;
+                let propName;
+                let options;
+                if (ts.isVariableDeclaration(parent) &&
+                    ts.isIdentifier(parent.name)) {
+                    localName = _getStartEnd(parent.name);
+                }
+                let runtimeType;
+                let defaultValue;
+                let required = false;
                 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;
-                                }
+                        options = node.arguments[1];
+                    }
+                    if (node.arguments.length >= 1) {
+                        propName = _getStartEnd(node.arguments[0]);
+                    }
+                    if (options && ts.isObjectLiteralExpression(options)) {
+                        for (const property of options.properties) {
+                            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+                                continue;
                             }
+                            const text = getNodeText(ts, property.name, ast);
+                            if (text === 'type') {
+                                runtimeType = _getStartEnd(property.initializer);
+                            }
+                            else if (text === 'default') {
+                                defaultValue = _getStartEnd(property.initializer);
+                            }
+                            else if (text === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                                required = true;
+                            }
+                        }
+                    }
+                }
+                else if (definePropProposalB) {
+                    if (node.arguments.length >= 3) {
+                        options = node.arguments[2];
+                    }
+                    if (node.arguments.length >= 2) {
+                        if (node.arguments[1].kind === ts.SyntaxKind.TrueKeyword) {
+                            required = true;
                         }
                     }
                     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,
-                        });
+                        defaultValue = _getStartEnd(node.arguments[0]);
                     }
-                    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,
-                        });
+                    if (options && ts.isObjectLiteralExpression(options)) {
+                        for (const property of options.properties) {
+                            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+                                continue;
+                            }
+                            const text = getNodeText(ts, property.name, ast);
+                            if (text === 'type') {
+                                runtimeType = _getStartEnd(property.initializer);
+                            }
+                        }
                     }
                 }
-                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,
-                    });
-                }
+                defineProp.push({
+                    localName,
+                    name: propName,
+                    type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                    runtimeType,
+                    defaultValue,
+                    required,
+                });
             }
             else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
                 slots.define = parseDefineFunction(node);
@@ -181,6 +229,14 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 expose.define = parseDefineFunction(node);
             }
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
+                if (ts.isVariableDeclaration(parent)) {
+                    if (ts.isObjectBindingPattern(parent.name)) {
+                        props.destructured = (0, common_1.collectVars)(ts, parent.name, ast, [], false);
+                    }
+                    else {
+                        props.name = getNodeText(ts, parent.name, ast);
+                    }
+                }
                 let statementRange;
                 for (let i = parents.length - 1; i >= 0; i--) {
                     if (ts.isStatement(parents[i])) {
@@ -200,9 +256,6 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     ...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]);
                 }
@@ -222,6 +275,15 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             else if (vueCompilerOptions.macros.defineOptions.includes(callText)) {
                 if (node.arguments.length && ts.isObjectLiteralExpression(node.arguments[0])) {
+                    const obj = node.arguments[0];
+                    ts.forEachChild(obj, node => {
+                        if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
+                            const name = getNodeText(ts, node.name, ast);
+                            if (name === 'inheritAttrs') {
+                                options.inheritAttrs = getNodeText(ts, node.initializer, ast);
+                            }
+                        }
+                    });
                     for (const prop of node.arguments[0].properties) {
                         if ((ts.isPropertyAssignment(prop)) && getNodeText(ts, prop.name, ast) === 'name' && ts.isStringLiteral(prop.initializer)) {
                             options.name = prop.initializer.text;
@@ -229,6 +291,27 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     }
                 }
             }
+            else if (vueCompilerOptions.macros.templateRef.includes(callText) && node.arguments.length && !node.typeArguments?.length) {
+                const define = parseDefineFunction(node);
+                define.arg = _getStartEnd(node.arguments[0]);
+                let name;
+                if (ts.isVariableDeclaration(parent)) {
+                    name = getNodeText(ts, parent.name, ast);
+                }
+                templateRefs.push({
+                    name,
+                    define
+                });
+            }
+            else if (vueCompilerOptions.composibles.useCssModule.includes(callText)) {
+                const module = {
+                    exp: _getStartEnd(node)
+                };
+                if (node.arguments.length) {
+                    module.arg = _getStartEnd(node.arguments[0]);
+                }
+                cssModules.push(module);
+            }
         }
         ts.forEachChild(node, child => {
             parents.push(node);

package/lib/plugins/file-md.js

@@ -72,14 +72,17 @@ const plugin = ({ vueCompilerOptions }) => {
             }
             return sfc;
             function transformRange(block) {
-                block.loc.start.offset = -1;
-                block.loc.end.offset = -1;
-                for (const [start] of file2VueSourceMap.toSourceLocation(block.loc.start.offset)) {
-                    block.loc.start.offset = start;
+                const { start, end } = block.loc;
+                const startOffset = start.offset;
+                const endOffset = end.offset;
+                start.offset = -1;
+                end.offset = -1;
+                for (const [offset] of file2VueSourceMap.toSourceLocation(startOffset)) {
+                    start.offset = offset;
                     break;
                 }
-                for (const [end] of file2VueSourceMap.toSourceLocation(block.loc.end.offset)) {
-                    block.loc.end.offset = end;
+                for (const [offset] of file2VueSourceMap.toSourceLocation(endOffset)) {
+                    end.offset = offset;
                     break;
                 }
             }

package/lib/plugins/vue-root-tags.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const muggle_string_1 = require("muggle-string");
+const shared_1 = require("./shared");
+const plugin = () => {
+    return {
+        version: 2.1,
+        getEmbeddedCodes() {
+            return [{
+                    id: 'root_tags',
+                    lang: 'vue-root-tags',
+                }];
+        },
+        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            if (embeddedFile.id === 'root_tags') {
+                embeddedFile.content.push([sfc.content, undefined, 0, shared_1.allCodeFeatures]);
+                for (const block of [
+                    sfc.script,
+                    sfc.scriptSetup,
+                    sfc.template,
+                    ...sfc.styles,
+                    ...sfc.customBlocks,
+                ]) {
+                    if (!block) {
+                        continue;
+                    }
+                    let content = block.content;
+                    if (content.endsWith('\r\n')) {
+                        content = content.slice(0, -2);
+                    }
+                    else if (content.endsWith('\n')) {
+                        content = content.slice(0, -1);
+                    }
+                    const offset = content.lastIndexOf('\n') + 1;
+                    // fix folding range end position failed to mapping
+                    (0, muggle_string_1.replaceSourceRange)(embeddedFile.content, undefined, block.startTagEnd, block.endTagStart, sfc.content.substring(block.startTagEnd, block.startTagEnd + offset), [
+                        '',
+                        undefined,
+                        block.startTagEnd + offset,
+                        { structure: true },
+                    ], sfc.content.substring(block.startTagEnd + offset, block.endTagStart));
+                }
+            }
+            else {
+                embeddedFile.parentCodeId ??= 'root_tags';
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-root-tags.js.map

package/lib/plugins/vue-tsx.d.ts

@@ -9,6 +9,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             componentsOption: import("../types").TextRange | undefined;
             componentsOptionNode: import("typescript").ObjectLiteralExpression | undefined;
             nameOption: import("../types").TextRange | undefined;
+            inheritAttrsOption: string | undefined;
         }) | undefined;
         classBlockEnd: number | undefined;
         bindings: import("../types").TextRange[];
@@ -20,6 +21,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         importComponentNames: Set<string>;
         props: {
             name?: string;
+            destructured?: string[];
             define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
                 arg?: import("../types").TextRange;
                 typeArg?: import("../types").TextRange;
@@ -54,23 +56,54 @@ export declare const tsCodegen: WeakMap<Sfc, {
                 typeArg?: import("../types").TextRange;
             }>;
         };
+        options: {
+            name?: string;
+            inheritAttrs?: string;
+        };
+        cssModules: {
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+        }[];
         defineProp: {
+            localName: import("../types").TextRange | undefined;
             name: import("../types").TextRange | undefined;
-            nameIsString: boolean;
             type: import("../types").TextRange | undefined;
             modifierType?: import("../types").TextRange | undefined;
+            runtimeType: import("../types").TextRange | undefined;
             defaultValue: import("../types").TextRange | undefined;
             required: boolean;
             isModel?: boolean;
         }[];
-        options: {
+        templateRefs: {
             name?: string;
-        };
+            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
+                arg?: import("../types").TextRange;
+                typeArg?: import("../types").TextRange;
+            }>;
+        }[];
     } | undefined;
     lang: () => string;
     generatedScript: () => {
         codes: Code[];
         linkedCodeMappings: Mapping<unknown>[];
+        generatedTemplate: boolean;
+        generatedPropsType: boolean;
+        scriptSetupGeneratedOffset: number | undefined;
+        bypassDefineComponent: boolean;
+        bindingNames: Set<string>;
+        localTypes: {
+            generate: (names: string[]) => Generator<string, void, unknown>;
+            getUsedNames(): Set<string>;
+            readonly PrettifyLocal: string;
+            readonly OmitKeepDiscriminatedUnion: string;
+            readonly WithDefaults: string;
+            readonly WithTemplateSlots: string;
+            readonly PropsChildren: string;
+            readonly TypePropsToOption: string;
+            readonly OmitIndexSignature: string;
+            readonly PickRefsExpose: string;
+        };
+        inlayHints: import("../codegen/types").InlayHintInfo[];
     };
     generatedTemplate: () => {
         codes: Code[];
@@ -103,11 +136,15 @@ export declare const tsCodegen: WeakMap<Sfc, {
         blockConditions: string[];
         usedComponentCtxVars: Set<string>;
         scopedClasses: {
+            source: string;
             className: string;
             offset: number;
         }[];
         emptyClassOffsets: number[];
+        inlayHints: import("../codegen/types").InlayHintInfo[];
         hasSlot: boolean;
+        inheritedAttrVars: Set<unknown>;
+        singleRootNode: import("@vue/compiler-dom").ElementNode | undefined;
         accessExternalVariable(name: string, offset?: number): void;
         hasLocalVariable: (name: string) => boolean;
         addLocalVariable: (name: string) => void;

package/lib/plugins/vue-tsx.js

@@ -8,6 +8,7 @@ const template_1 = require("../codegen/template");
 const scriptRanges_1 = require("../parsers/scriptRanges");
 const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
 exports.tsCodegen = new WeakMap();
+const fileEditTimes = new Map();
 const plugin = ctx => {
     return {
         version: 2.1,
@@ -67,11 +68,14 @@ function createTsx(fileName, _sfc, ctx) {
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: ctx.vueCompilerOptions,
             template: _sfc.template,
+            edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
             scriptSetupBindingNames: scriptSetupBindingNames(),
             scriptSetupImportComponentNames: scriptSetupImportComponentNames(),
+            templateRefNames: new Map(),
             hasDefineSlots: hasDefineSlots(),
             slotsAssignName: slotsAssignName(),
             propsAssignName: propsAssignName(),
+            inheritAttrs: inheritAttrs(),
         });
         let current = codegen.next();
         while (!current.done) {
@@ -107,15 +111,18 @@ function createTsx(fileName, _sfc, ctx) {
     });
     const slotsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.slots.name);
     const propsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.props.name);
+    const inheritAttrs = (0, computeds_1.computed)(() => {
+        const value = scriptSetupRanges()?.options.inheritAttrs ?? scriptRanges()?.exportDefault?.inheritAttrsOption;
+        return value !== 'false';
+    });
     const generatedScript = (0, computeds_1.computed)(() => {
         const codes = [];
         const linkedCodeMappings = [];
         const _template = generatedTemplate();
         let generatedLength = 0;
-        for (const code of (0, script_1.generateScript)({
+        const codegen = (0, script_1.generateScript)({
             ts,
             fileBaseName: path.basename(fileName),
-            globalTypes: ctx.globalTypesHolder === fileName,
             sfc: _sfc,
             lang: lang(),
             scriptRanges: scriptRanges(),
@@ -123,16 +130,22 @@ function createTsx(fileName, _sfc, ctx) {
             templateCodegen: _template,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: ctx.vueCompilerOptions,
+            edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
             getGeneratedLength: () => generatedLength,
             linkedCodeMappings,
-        })) {
+        });
+        fileEditTimes.set(fileName, (fileEditTimes.get(fileName) ?? 0) + 1);
+        let current = codegen.next();
+        while (!current.done) {
+            const code = current.value;
             codes.push(code);
             generatedLength += typeof code === 'string'
                 ? code.length
                 : code[0].length;
+            current = codegen.next();
         }
-        ;
         return {
+            ...current.value,
             codes,
             linkedCodeMappings,
         };

package/lib/plugins.js

@@ -18,6 +18,7 @@ exports.createPlugins = createPlugins;
 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_root_tags_1 = require("./plugins/vue-root-tags");
 const vue_script_js_1 = require("./plugins/vue-script-js");
 const vue_sfc_customblocks_1 = require("./plugins/vue-sfc-customblocks");
 const vue_sfc_scripts_1 = require("./plugins/vue-sfc-scripts");
@@ -34,6 +35,7 @@ function createPlugins(pluginContext) {
         file_vue_1.default,
         file_md_1.default,
         file_html_1.default,
+        vue_root_tags_1.default,
         vue_script_js_1.default,
         vue_template_html_1.default,
         vue_template_inline_css_1.default,

package/lib/types.d.ts

@@ -11,13 +11,6 @@ export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' |
     plugins?: string[];
 };
 export interface VueCodeInformation extends CodeInformation {
-    __hint?: {
-        setting: string;
-        label: string;
-        tooltip: string;
-        paddingRight?: boolean;
-        paddingLeft?: boolean;
-    };
     __combineLastMapping?: boolean;
     __combineOffsetMapping?: number;
 }
@@ -31,6 +24,7 @@ export interface VueCompilerOptions {
     jsxSlots: boolean;
     strictTemplates: boolean;
     skipTemplateCodegen: boolean;
+    fallthroughAttributes: boolean;
     dataAttributes: string[];
     htmlAttributes: string[];
     optionsWrapper: [string, string] | [];
@@ -42,11 +36,16 @@ export interface VueCompilerOptions {
         defineModel: string[];
         defineOptions: string[];
         withDefaults: string[];
+        templateRef: string[];
+    };
+    composibles: {
+        useCssModule: string[];
     };
     plugins: VueLanguagePlugin[];
     experimentalDefinePropProposal: 'kevinEdition' | 'johnsonEdition' | false;
     experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
     experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
+    __test?: boolean;
 }
 export declare const validVersions: readonly [2, 2.1];
 export type VueLanguagePluginReturn = {
@@ -84,7 +83,6 @@ export type VueLanguagePlugin = (ctx: {
     };
     compilerOptions: ts.CompilerOptions;
     vueCompilerOptions: VueCompilerOptions;
-    globalTypesHolder: string | undefined;
 }) => VueLanguagePluginReturn | VueLanguagePluginReturn[];
 export interface SfcBlock {
     name: string;
@@ -96,7 +94,14 @@ export interface SfcBlock {
     content: string;
     attrs: Record<string, string | true>;
 }
+export interface SFCStyleOverride {
+    module?: {
+        name: string;
+        offset?: number;
+    };
+}
 export interface Sfc {
+    content: string;
     template: SfcBlock & {
         ast: CompilerDOM.RootNode | undefined;
         errors: CompilerDOM.CompilerError[];
@@ -112,8 +117,7 @@ export interface Sfc {
         genericOffset: number;
         ast: ts.SourceFile;
     } | undefined;
-    styles: readonly (SfcBlock & {
-        module: string | undefined;
+    styles: readonly (SfcBlock & SFCStyleOverride & {
         scoped: boolean;
         cssVars: {
             text: string;

package/lib/utils/findDestructuredProps.js

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

package/lib/utils/parseCssClassNames.js

@@ -2,16 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCssClassNames = parseCssClassNames;
 const parseCssVars_1 = require("./parseCssVars");
-const cssClassNameReg = /(?=([\.]{1}[a-zA-Z_]+[\w\_\-]*)[\s\.\,\+\{\>#\:]{1})/g;
+const cssClassNameReg = /(?=(\.[a-z_][-\w]*)[\s.,+~>:#[{])/gi;
 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 };
-            }
+        const matchText = match[1];
+        if (matchText) {
+            yield { offset: match.index, text: matchText };
         }
     }
 }

package/lib/utils/parseCssVars.js

@@ -3,19 +3,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCssVars = parseCssVars;
 exports.clearComments = clearComments;
-const vBindCssVarReg = /\bv-bind\(\s*(?:'([^']+)'|"([^"]+)"|([^'"][^)]*))\s*\)/g;
+const vBindCssVarReg = /\bv-bind\(\s*(?:'([^']+)'|"([^"]+)"|([a-z_]\w*))\s*\)/gi;
 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 };
-            }
+        const matchText = match.slice(1).find(t => t);
+        if (matchText) {
+            const offset = match.index + styleContent.slice(match.index).indexOf(matchText);
+            yield { offset, text: matchText };
         }
     }
 }

package/lib/utils/parseSfc.js

@@ -107,7 +107,10 @@ function createBlock(node, source) {
                     block.scoped = true;
                 }
                 else if (p.name === 'module') {
-                    block.module = attrs[p.name];
+                    block.module = {
+                        name: p.value?.content ?? '$style',
+                        offset: p.value?.content ? p.value?.loc.start.offset - node.loc.start.offset : undefined
+                    };
                 }
             }
             else if (type === 'script' && p.name === 'setup') {