@vue/language-core 2.0.15 → 2.0.17

package/lib/codegen/template/slotOutlet.js

@@ -29,41 +29,40 @@ function* generateSlotOutlet(options, ctx, node, currentComponent, componentCtxV
         yield `)?.(`;
         yield* (0, common_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{${common_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true), `}`);
         yield `)${common_1.endOfLine}`;
-        return;
     }
     else {
         yield `var ${varSlot} = {${common_1.newLine}`;
         yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true);
         yield `}${common_1.endOfLine}`;
-    }
-    if (nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE
-        && nameProp.value) {
-        ctx.slots.push({
-            name: nameProp.value.content,
-            loc: nameProp.loc.start.offset + nameProp.loc.source.indexOf(nameProp.value.content, nameProp.name.length),
-            tagRange: [startTagOffset, startTagOffset + node.tag.length],
-            varName: varSlot,
-            nodeLoc: node.loc,
-        });
-    }
-    else if (nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE
-        && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        const slotExpVar = ctx.getInternalVariable();
-        yield `var ${slotExpVar} = `;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, nameProp.exp.content, nameProp.exp, nameProp.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')');
-        yield ` as const${common_1.endOfLine}`;
-        ctx.dynamicSlots.push({
-            expVar: slotExpVar,
-            varName: varSlot,
-        });
-    }
-    else {
-        ctx.slots.push({
-            name: 'default',
-            tagRange: [startTagOffset, startTagOffset + node.tag.length],
-            varName: varSlot,
-            nodeLoc: node.loc,
-        });
+        if (nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && nameProp.value) {
+            ctx.slots.push({
+                name: nameProp.value.content,
+                loc: nameProp.loc.start.offset + nameProp.loc.source.indexOf(nameProp.value.content, nameProp.name.length),
+                tagRange: [startTagOffset, startTagOffset + node.tag.length],
+                varName: varSlot,
+                nodeLoc: node.loc,
+            });
+        }
+        else if (nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            const slotExpVar = ctx.getInternalVariable();
+            yield `var ${slotExpVar} = `;
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, nameProp.exp.content, nameProp.exp, nameProp.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+            yield ` as const${common_1.endOfLine}`;
+            ctx.dynamicSlots.push({
+                expVar: slotExpVar,
+                varName: varSlot,
+            });
+        }
+        else {
+            ctx.slots.push({
+                name: 'default',
+                tagRange: [startTagOffset, startTagOffset + node.tag.length],
+                varName: varSlot,
+                nodeLoc: node.loc,
+            });
+        }
     }
     yield* ctx.generateAutoImportCompletion();
     yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentComponent, componentCtxVar);

package/lib/languageModule.d.ts

@@ -6,4 +6,4 @@ export interface _Plugin extends LanguagePlugin<VueVirtualCode> {
     getCanonicalFileName: (fileName: string) => string;
     pluginContext: Parameters<VueLanguagePlugin>[0];
 }
-export declare function createVueLanguagePlugin(ts: typeof import('typescript'), getFileName: (fileId: string) => string, useCaseSensitiveFileNames: boolean, getProjectVersion: () => string, getScriptFileNames: () => string[] | Set<string>, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): _Plugin;
+export declare function createVueLanguagePlugin(ts: typeof import('typescript'), getFileName: (scriptId: string) => string, useCaseSensitiveFileNames: boolean, getProjectVersion: () => string, getScriptFileNames: () => string[] | Set<string>, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): _Plugin;

package/lib/languageModule.js

@@ -76,9 +76,9 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
                 return 'html';
             }
         },
-        createVirtualCode(fileId, languageId, snapshot) {
+        createVirtualCode(scriptId, languageId, snapshot) {
             if (languageId === 'vue' || languageId === 'markdown' || languageId === 'html') {
-                const fileName = getFileName(fileId);
+                const fileName = getFileName(scriptId);
                 const projectVersion = getProjectVersion();
                 if (projectVersion !== canonicalRootFileNamesVersion) {
                     canonicalRootFileNames = new Set([...getScriptFileNames()].map(getCanonicalFileName));
@@ -88,7 +88,7 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
                     pluginContext.globalTypesHolder = fileName;
                 }
                 const fileRegistry = getFileRegistry(pluginContext.globalTypesHolder === fileName);
-                const code = fileRegistry.get(fileId);
+                const code = fileRegistry.get(scriptId);
                 if (code) {
                     code.update(snapshot);
                     return code;
@@ -99,7 +99,7 @@ function createVueLanguagePlugin(ts, getFileName, useCaseSensitiveFileNames, get
                         : languageId === 'markdown'
                             ? [vitePressSfcPlugin, ...basePlugins]
                             : [vueSfcPlugin, ...basePlugins], ts);
-                    fileRegistry.set(fileId, code);
+                    fileRegistry.set(scriptId, code);
                     return code;
                 }
             }

package/lib/parsers/scriptRanges.d.ts

@@ -11,5 +11,6 @@ export declare function parseScriptRanges(ts: typeof import('typescript'), ast:
         componentsOptionNode: ts.ObjectLiteralExpression | undefined;
         nameOption: TextRange | undefined;
     }) | undefined;
+    classBlockEnd: number | undefined;
     bindings: TextRange[];
 };

package/lib/parsers/scriptRanges.js

@@ -4,6 +4,7 @@ exports.parseScriptRanges = void 0;
 const scriptSetupRanges_1 = require("./scriptSetupRanges");
 function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
     let exportDefault;
+    let classBlockEnd;
     const bindings = hasScriptSetup ? (0, scriptSetupRanges_1.parseBindingRanges)(ts, ast) : [];
     ts.forEachChild(ast, raw => {
         if (ts.isExportAssignment(raw)) {
@@ -46,9 +47,15 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
                 };
             }
         }
+        if (ts.isClassDeclaration(raw)
+            && raw.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)
+            && raw.modifiers?.some(mod => mod.kind === ts.SyntaxKind.DefaultKeyword)) {
+            classBlockEnd = raw.end - 1;
+        }
     });
     return {
         exportDefault,
+        classBlockEnd,
         bindings,
     };
     function _getStartEnd(node) {

package/lib/parsers/scriptSetupRanges.d.ts

@@ -6,6 +6,7 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     leadingCommentEndOffset: number;
     importSectionEndOffset: number;
     bindings: TextRange[];
+    importComponentNames: Set<string>;
     props: {
         name?: string | undefined;
         define?: (TextRange & {
@@ -49,6 +50,9 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
         required: boolean;
         isModel?: boolean | undefined;
     }[];
+    options: {
+        name?: string | undefined;
+    };
 };
 export declare function parseBindingRanges(ts: typeof import('typescript'), sourceFile: ts.SourceFile): TextRange[];
 export declare function findBindingVars(ts: typeof import('typescript'), left: ts.BindingName, sourceFile: ts.SourceFile): TextRange[];

package/lib/parsers/scriptSetupRanges.js

@@ -8,12 +8,14 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const slots = {};
     const emits = {};
     const expose = {};
+    const options = {};
     const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition' || ast.text.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition');
     const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition' || ast.text.trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition');
     const defineProp = [];
     const bindings = parseBindingRanges(ts, ast);
     const text = ast.text;
     const leadingCommentEndOffset = ts.getLeadingCommentRanges(text, 0)?.reverse()[0].end ?? 0;
+    const importComponentNames = new Set();
     ts.forEachChild(ast, node => {
         const isTypeExport = (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) && node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
         if (!foundNonImportExportNode
@@ -32,17 +34,27 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             foundNonImportExportNode = true;
         }
+        if (ts.isImportDeclaration(node)
+            && node.importClause?.name
+            && !node.importClause.isTypeOnly) {
+            const moduleName = getNodeText(ts, node.moduleSpecifier, ast).slice(1, -1);
+            if (vueCompilerOptions.extensions.some(ext => moduleName.endsWith(ext))) {
+                importComponentNames.add(getNodeText(ts, node.importClause.name, ast));
+            }
+        }
     });
     ts.forEachChild(ast, child => visitNode(child, [ast]));
     return {
         leadingCommentEndOffset,
         importSectionEndOffset,
         bindings,
+        importComponentNames,
         props,
         slots,
         emits,
         expose,
         defineProp,
+        options,
     };
     function _getStartEnd(node) {
         return getStartEnd(ts, node, ast);
@@ -196,6 +208,15 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     props.name = getNodeText(ts, parent.name, ast);
                 }
             }
+            else if (vueCompilerOptions.macros.defineOptions.includes(callText)) {
+                if (node.arguments.length && ts.isObjectLiteralExpression(node.arguments[0])) {
+                    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;
+                        }
+                    }
+                }
+            }
         }
         ts.forEachChild(node, child => {
             parents.push(node);
@@ -237,6 +258,9 @@ function parseBindingRanges(ts, sourceFile) {
                 if (node.importClause.namedBindings) {
                     if (ts.isNamedImports(node.importClause.namedBindings)) {
                         for (const element of node.importClause.namedBindings.elements) {
+                            if (element.isTypeOnly) {
+                                continue;
+                            }
                             bindings.push(_getStartEnd(element.name));
                         }
                     }

package/lib/plugins/vue-template-inline-ts.js

@@ -74,7 +74,7 @@ const plugin = ctx => {
                     if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
                         && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY // style='z-index: 2' will compile to {'z-index':'2'}
                     ) {
-                        if (prop.name === 'on') {
+                        if (prop.name === 'on' && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
                             const ast = (0, common_1.createTsAst)(ctx.modules.typescript, prop.exp, prop.exp.content);
                             addFormatCodes(prop.exp.content, prop.exp.loc.start.offset, (0, elementEvents_1.isCompoundExpression)(ctx.modules.typescript, ast)
                                 ? formatBrackets.event

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

@@ -10,12 +10,14 @@ export declare const tsCodegen: WeakMap<Sfc, {
             componentsOptionNode: import("typescript").ObjectLiteralExpression | undefined;
             nameOption: import("../types").TextRange | undefined;
         }) | undefined;
+        classBlockEnd: number | undefined;
         bindings: import("../types").TextRange[];
     } | undefined;
     scriptSetupRanges: () => {
         leadingCommentEndOffset: number;
         importSectionEndOffset: number;
         bindings: import("../types").TextRange[];
+        importComponentNames: Set<string>;
         props: {
             name?: string | undefined;
             define?: (import("../types").TextRange & {
@@ -59,6 +61,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
             required: boolean;
             isModel?: boolean | undefined;
         }[];
+        options: {
+            name?: string | undefined;
+        };
     } | undefined;
     lang: () => string;
     generatedScript: () => {
@@ -67,48 +72,49 @@ export declare const tsCodegen: WeakMap<Sfc, {
     };
     generatedTemplate: () => {
         codes: Code[];
-        ctx: {
-            slots: {
-                name: string;
-                loc?: number | undefined;
-                tagRange: [number, number];
-                varName: string;
-                nodeLoc: any;
-            }[];
-            dynamicSlots: {
-                expVar: string;
-                varName: string;
-            }[];
-            codeFeatures: {
-                all: import("../types").VueCodeInformation;
-                verification: import("../types").VueCodeInformation;
-                completion: import("../types").VueCodeInformation;
-                additionalCompletion: import("../types").VueCodeInformation;
-                navigation: import("../types").VueCodeInformation;
-                navigationAndCompletion: import("../types").VueCodeInformation;
-                withoutHighlight: import("../types").VueCodeInformation;
-                withoutHighlightAndCompletion: import("../types").VueCodeInformation;
-                withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
-            };
-            accessGlobalVariables: Map<string, Set<number>>;
-            hasSlotElements: Set<import("@vue/compiler-dom").ElementNode>;
-            blockConditions: string[];
-            usedComponentCtxVars: Set<string>;
-            scopedClasses: {
-                className: string;
-                offset: number;
-            }[];
-            accessGlobalVariable(name: string, offset?: number | undefined): void;
-            hasLocalVariable: (name: string) => boolean;
-            addLocalVariable: (name: string) => void;
-            removeLocalVariable: (name: string) => void;
-            getInternalVariable: () => string;
-            ignoreError: () => Generator<Code, any, unknown>;
-            expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code, any, unknown>;
-            resetDirectiveComments: (endStr: string) => Generator<Code, any, unknown>;
-            generateAutoImportCompletion: () => Generator<Code, any, unknown>;
+        slots: {
+            name: string;
+            loc?: number | undefined;
+            tagRange: [number, number];
+            varName: string;
+            nodeLoc: any;
+        }[];
+        dynamicSlots: {
+            expVar: string;
+            varName: string;
+        }[];
+        codeFeatures: {
+            all: import("../types").VueCodeInformation;
+            verification: import("../types").VueCodeInformation;
+            completion: import("../types").VueCodeInformation;
+            additionalCompletion: import("../types").VueCodeInformation;
+            navigation: import("../types").VueCodeInformation;
+            navigationWithoutRename: import("../types").VueCodeInformation;
+            navigationAndCompletion: import("../types").VueCodeInformation;
+            navigationAndAdditionalCompletion: import("../types").VueCodeInformation;
+            withoutHighlight: import("../types").VueCodeInformation;
+            withoutHighlightAndCompletion: import("../types").VueCodeInformation;
+            withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
         };
+        accessExternalVariables: Map<string, Set<number>>;
+        hasSlotElements: Set<import("@vue/compiler-dom").ElementNode>;
+        blockConditions: string[];
+        usedComponentCtxVars: Set<string>;
+        scopedClasses: {
+            className: string;
+            offset: number;
+        }[];
+        emptyClassOffsets: number[];
         hasSlot: boolean;
+        accessExternalVariable(name: string, offset?: number | undefined): void;
+        hasLocalVariable: (name: string) => boolean;
+        addLocalVariable: (name: string) => void;
+        removeLocalVariable: (name: string) => void;
+        getInternalVariable: () => string;
+        ignoreError: () => Generator<Code, any, unknown>;
+        expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code, any, unknown>;
+        resetDirectiveComments: (endStr: string) => Generator<Code, any, unknown>;
+        generateAutoImportCompletion: () => Generator<Code, any, unknown>;
     } | undefined;
 }>;
 declare const plugin: VueLanguagePlugin;

package/lib/plugins/vue-tsx.js

@@ -57,27 +57,6 @@ function createTsx(fileName, _sfc, ctx) {
     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;
@@ -88,8 +67,8 @@ function createTsx(fileName, _sfc, ctx) {
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: ctx.vueCompilerOptions,
             template: _sfc.template,
-            shouldGenerateScopedClasses: shouldGenerateScopedClasses(),
-            stylesScopedClasses: stylesScopedClasses(),
+            scriptSetupBindingNames: scriptSetupBindingNames(),
+            scriptSetupImportComponentNames: scriptSetupImportComponentNames(),
             hasDefineSlots: hasDefineSlots(),
             slotsAssignName: slotsAssignName(),
             propsAssignName: propsAssignName(),
@@ -106,6 +85,26 @@ function createTsx(fileName, _sfc, ctx) {
         };
     });
     const hasDefineSlots = (0, computeds_1.computed)(() => !!scriptSetupRanges()?.slots.define);
+    const scriptSetupBindingNames = (0, computeds_1.computed)(oldNames => {
+        const newNames = new Set();
+        const bindings = scriptSetupRanges()?.bindings;
+        if (_sfc.scriptSetup && bindings) {
+            for (const binding of bindings) {
+                newNames.add(_sfc.scriptSetup?.content.substring(binding.start, binding.end));
+            }
+        }
+        if (newNames && oldNames && twoSetsEqual(newNames, oldNames)) {
+            return oldNames;
+        }
+        return newNames;
+    });
+    const scriptSetupImportComponentNames = (0, computeds_1.computed)(oldNames => {
+        const newNames = scriptSetupRanges()?.importComponentNames ?? new Set();
+        if (newNames && oldNames && twoSetsEqual(newNames, oldNames)) {
+            return oldNames;
+        }
+        return newNames;
+    });
     const slotsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.slots.name);
     const propsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.props.name);
     const generatedScript = (0, computeds_1.computed)(() => {
@@ -121,11 +120,7 @@ function createTsx(fileName, _sfc, ctx) {
             lang: lang(),
             scriptRanges: scriptRanges(),
             scriptSetupRanges: scriptSetupRanges(),
-            templateCodegen: _template ? {
-                tsCodes: _template.codes,
-                ctx: _template.ctx,
-                hasSlot: _template.hasSlot,
-            } : undefined,
+            templateCodegen: _template,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: ctx.vueCompilerOptions,
             getGeneratedLength: () => generatedLength,
@@ -150,4 +145,15 @@ function createTsx(fileName, _sfc, ctx) {
         generatedTemplate,
     };
 }
+function twoSetsEqual(a, b) {
+    if (a.size !== b.size) {
+        return false;
+    }
+    for (const file of a) {
+        if (!b.has(file)) {
+            return false;
+        }
+    }
+    return true;
+}
 //# sourceMappingURL=vue-tsx.js.map

package/lib/plugins.d.ts

@@ -22,5 +22,5 @@ export declare function getBasePlugins(pluginContext: Parameters<VueLanguagePlug
         id: string;
         lang: string;
     }[];
-    resolveEmbeddedCode?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./virtualFile/embeddedFile").VueEmbeddedCode): void;
+    resolveEmbeddedCode?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./types").VueEmbeddedCode): void;
 }[];

package/lib/types.d.ts

@@ -4,13 +4,12 @@ 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 { VueEmbeddedCode };
 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;
@@ -47,7 +46,6 @@ export interface VueCompilerOptions {
     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: {
@@ -123,18 +121,6 @@ export interface Sfc {
     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;

package/lib/utils/parseCssClassNames.js

@@ -2,7 +2,7 @@
 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;
+const cssClassNameReg = /(?=([\.]{1}[a-zA-Z_]+[\w\_\-]*)[\s\.\,\+\{\>#\:]{1})/g;
 function* parseCssClassNames(styleContent) {
     styleContent = (0, parseCssVars_1.clearComments)(styleContent);
     const matches = styleContent.matchAll(cssClassNameReg);

package/lib/utils/ts.js

@@ -210,7 +210,6 @@ function resolveVueCompilerOptions(vueOptions) {
                 select: true
             }
         },
-        experimentalUseElementAccessInTemplate: vueOptions.experimentalUseElementAccessInTemplate ?? false,
     };
 }
 exports.resolveVueCompilerOptions = resolveVueCompilerOptions;