@vue/language-core 1.7.0 → 1.7.3

package/out/generators/script.d.ts

@@ -5,10 +5,10 @@ import type * as ts from 'typescript/lib/tsserverlibrary';
 import type * as templateGen from '../generators/template';
 import type { ScriptRanges } from '../parsers/scriptRanges';
 import type { ScriptSetupRanges } from '../parsers/scriptSetupRanges';
-import { collectCssVars, collectStyleCssClasses } from '../plugins/vue-tsx';
 import { Sfc } from '../types';
 import type { VueCompilerOptions } from '../types';
-export declare function generate(ts: typeof import('typescript/lib/tsserverlibrary'), fileName: string, _sfc: Sfc, lang: string, scriptRanges: ScriptRanges | undefined, scriptSetupRanges: ScriptSetupRanges | undefined, cssVars: ReturnType<typeof collectCssVars>, cssModuleClasses: ReturnType<typeof collectStyleCssClasses>, cssScopedClasses: ReturnType<typeof collectStyleCssClasses>, htmlGen: ReturnType<typeof templateGen['generate']> | undefined, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, sharedTypesImport: string): {
+export declare function generate(ts: typeof import('typescript/lib/tsserverlibrary'), fileName: string, _sfc: Sfc, lang: string, scriptRanges: ScriptRanges | undefined, scriptSetupRanges: ScriptSetupRanges | undefined, htmlGen: ReturnType<typeof templateGen['generate']> | undefined, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, sharedTypesImport: string, codegenStack: boolean): {
     codes: Segment<FileRangeCapabilities>[];
+    codeStacks: SourceMaps.StackNode[];
     mirrorBehaviorMappings: SourceMaps.Mapping<[MirrorBehaviorCapabilities, MirrorBehaviorCapabilities]>[];
 };

package/out/generators/script.js

@@ -9,8 +9,8 @@ const shared_2 = require("../utils/shared");
 const transform_1 = require("../utils/transform");
 const sharedTypes = require("../utils/directorySharedTypes");
 const muggle = require("muggle-string");
-function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, cssVars, cssModuleClasses, cssScopedClasses, htmlGen, compilerOptions, vueCompilerOptions, sharedTypesImport) {
-    const codes = [];
+function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, htmlGen, compilerOptions, vueCompilerOptions, sharedTypesImport, codegenStack) {
+    const [codes, codeStacks] = codegenStack ? muggle.track([]) : [[], []];
     const mirrorBehaviorMappings = [];
     //#region monkey fix: https://github.com/vuejs/language-tools/pull/2113
     const sfc = {
@@ -78,6 +78,7 @@ function generate(ts, fileName, _sfc, lang, scriptRanges, scriptSetupRanges, css
     }
     return {
         codes,
+        codeStacks,
         mirrorBehaviorMappings,
     };
     function generateHelperTypes() {
@@ -717,10 +718,13 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         }
         codes.push(`InstanceType<import('${sharedTypesImport}').PickNotAny<typeof __VLS_internalComponent, new () => {}>> & {\n`);
         /* CSS Module */
-        for (const cssModule of cssModuleClasses) {
-            codes.push(`${cssModule.style.module}: Record<string, string> & import('${sharedTypesImport}').Prettify<{}`);
-            for (const classNameRange of cssModule.classNameRanges) {
-                generateCssClassProperty(cssModule.index, cssModule.style.content.substring(classNameRange.start + 1, classNameRange.end), classNameRange, 'string', false);
+        for (let i = 0; i < _sfc.styles.length; i++) {
+            const style = _sfc.styles[i];
+            if (!style.module)
+                continue;
+            codes.push(`${style.module}: Record<string, string> & import('${sharedTypesImport}').Prettify<{}`);
+            for (const className of style.classNames) {
+                generateCssClassProperty(i, className.text.substring(1), { start: className.offset, end: className.offset + className.text.length }, 'string', false);
             }
             codes.push('>;\n');
         }
@@ -734,9 +738,12 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         /* Style Scoped */
         codes.push('/* Style Scoped */\n');
         codes.push('type __VLS_StyleScopedClasses = {}');
-        for (const scopedCss of cssScopedClasses) {
-            for (const classNameRange of scopedCss.classNameRanges) {
-                generateCssClassProperty(scopedCss.index, scopedCss.style.content.substring(classNameRange.start + 1, classNameRange.end), classNameRange, 'boolean', true);
+        for (let i = 0; i < _sfc.styles.length; i++) {
+            const style = _sfc.styles[i];
+            if (!style.scoped)
+                continue;
+            for (const className of style.classNames) {
+                generateCssClassProperty(i, className.text.substring(1), { start: className.offset, end: className.offset + className.text.length }, 'boolean', true);
             }
         }
         codes.push(';\n');
@@ -745,9 +752,14 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         const cssIds = generateCssVars();
         codes.push(`/* CSS variable injection end */\n`);
         if (htmlGen) {
+            muggle.setTracking(false);
             for (const s of htmlGen.codes) {
                 codes.push(s);
             }
+            muggle.setTracking(true);
+            for (const s of htmlGen.codeStacks) {
+                codeStacks.push(s);
+            }
         }
         if (!htmlGen) {
             codes.push(`// no template\n`);
@@ -799,18 +811,17 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         function generateCssVars() {
             const emptyLocalVars = {};
             const identifiers = new Set();
-            for (const cssVar of cssVars) {
-                for (const cssBind of cssVar.ranges) {
-                    const code = cssVar.style.content.substring(cssBind.start, cssBind.end);
-                    (0, transform_1.walkInterpolationFragment)(ts, code, ts.createSourceFile('/a.txt', code, ts.ScriptTarget.ESNext), (frag, fragOffset, onlyForErrorMapping) => {
+            for (const style of _sfc.styles) {
+                for (const cssBind of style.cssVars) {
+                    (0, transform_1.walkInterpolationFragment)(ts, cssBind.text, ts.createSourceFile('/a.txt', cssBind.text, ts.ScriptTarget.ESNext), (frag, fragOffset, onlyForErrorMapping) => {
                         if (fragOffset === undefined) {
                             codes.push(frag);
                         }
                         else {
                             codes.push([
                                 frag,
-                                cssVar.style.name,
-                                cssBind.start + fragOffset,
+                                style.name,
+                                cssBind.offset + fragOffset,
                                 onlyForErrorMapping
                                     ? { diagnostic: true }
                                     : language_core_1.FileRangeCapabilities.full,
@@ -851,14 +862,17 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
         return usageVars;
     }
     function addVirtualCode(vueTag, start, end) {
+        muggle.offsetStack();
         codes.push([
             sfc[vueTag].content.substring(start, end),
             vueTag,
             start,
             language_core_1.FileRangeCapabilities.full, // diagnostic also working for setup() returns unused in template checking
         ]);
+        muggle.resetOffsetStack();
     }
     function addExtraReferenceVirtualCode(vueTag, start, end) {
+        muggle.offsetStack();
         codes.push([
             sfc[vueTag].content.substring(start, end),
             vueTag,
@@ -869,6 +883,7 @@ declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?:
                 rename: true,
             },
         ]);
+        muggle.resetOffsetStack();
     }
 }
 exports.generate = generate;

package/out/generators/template.d.ts

@@ -2,12 +2,16 @@ import { Segment } from '@volar/source-map';
 import { FileRangeCapabilities } from '@volar/language-core';
 import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript/lib/tsserverlibrary';
-import { VueCompilerOptions } from '../types';
+import { Sfc, VueCompilerOptions } from '../types';
+import * as muggle from 'muggle-string';
 type Code = Segment<FileRangeCapabilities>;
-export declare function generate(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, sourceTemplate: string, sourceLang: string, templateAst: CompilerDOM.RootNode, hasScriptSetupSlots: boolean, sharedTypesImport: string, cssScopedClasses?: string[]): {
+export declare function generate(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, sourceTemplate: string, sourceLang: string, sfc: Sfc, hasScriptSetupSlots: boolean, sharedTypesImport: string, codegenStack: boolean): {
     codes: Code[];
+    codeStacks: muggle.StackNode[];
     formatCodes: Code[];
+    formatCodeStacks: muggle.StackNode[];
     cssCodes: Code[];
+    cssCodeStacks: muggle.StackNode[];
     tagNames: Record<string, number[]>;
     identifiers: Set<string>;
     hasSlot: boolean;

package/out/generators/template.js

@@ -57,13 +57,12 @@ const transformContext = {
     },
     expressionPlugins: ['typescript'],
 };
-function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourceLang, templateAst, hasScriptSetupSlots, sharedTypesImport, cssScopedClasses = []) {
-    const codes = [];
-    const formatCodes = [];
-    const cssCodes = [];
+function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourceLang, sfc, hasScriptSetupSlots, sharedTypesImport, codegenStack) {
+    const [codes, codeStacks] = codegenStack ? muggle.track([]) : [[], []];
+    const [formatCodes, formatCodeStacks] = codegenStack ? muggle.track([]) : [[], []];
+    const [cssCodes, cssCodeStacks] = codegenStack ? muggle.track([]) : [[], []];
     const slots = new Map();
     const slotExps = new Map();
-    const cssScopedClassesSet = new Set(cssScopedClasses);
     const tagNames = collectTagOffsets();
     const localVars = {};
     const tempVars = [];
@@ -73,7 +72,9 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
     let hasSlot = false;
     let elementIndex = 0;
     const componentVars = generateComponentVars();
-    visitNode(templateAst, undefined, undefined);
+    if (sfc.templateAst) {
+        visitNode(sfc.templateAst, undefined, undefined);
+    }
     generateStyleScopedClasses();
     if (!hasScriptSetupSlots) {
         codes.push('var __VLS_slots!:', ...createSlotsTypeCode(), ';\n');
@@ -81,8 +82,11 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
     generateAutoImportCompletionCode();
     return {
         codes,
+        codeStacks,
         formatCodes,
+        formatCodeStacks,
         cssCodes,
+        cssCodeStacks,
         tagNames,
         identifiers,
         hasSlot,
@@ -111,6 +115,14 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
         return codes;
     }
     function generateStyleScopedClasses() {
+        const allClasses = new Set();
+        for (const block of sfc.styles) {
+            if (block.scoped) {
+                for (const className of block.classNames) {
+                    allClasses.add(className.text.substring(1));
+                }
+            }
+        }
         codes.push(`if (typeof __VLS_styleScopedClasses === 'object' && !Array.isArray(__VLS_styleScopedClasses)) {\n`);
         for (const { className, offset } of scopedClasses) {
             codes.push(`__VLS_styleScopedClasses[`);
@@ -120,7 +132,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
                 offset,
                 {
                     ...capabilitiesPresets.scopedClassName,
-                    displayWithLink: cssScopedClassesSet.has(className),
+                    displayWithLink: allClasses.has(className),
                 },
             ]));
             codes.push(`];\n`);
@@ -192,7 +204,10 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
     }
     function collectTagOffsets() {
         const tagOffsetsMap = {};
-        walkElementNodes(templateAst, node => {
+        if (!sfc.templateAst) {
+            return tagOffsetsMap;
+        }
+        walkElementNodes(sfc.templateAst, node => {
             if (node.tag === 'slot') {
                 // ignore
             }
@@ -466,7 +481,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
         }
         generateDirectives(node, var_originalComponent);
         generateElReferences(node); // <el ref="foo" />
-        if (cssScopedClasses.length) {
+        if (sfc.styles.some(s => s.scoped)) {
             generateClassScoped(node);
         }
         if (componentCtxVar) {
@@ -507,7 +522,7 @@ function generate(ts, compilerOptions, vueCompilerOptions, sourceTemplate, sourc
                     ], ` = (await import('${sharedTypesImport}')).getSlotParam(`);
                 }
             }
-            codes.push(['', 'template', (slotDir.arg ?? slotDir).loc.start.offset, capabilitiesPresets.diagnosticOnly], `${componentCtxVar}.slots!`, ...((slotDir?.arg?.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */ && slotDir.arg.content)
+            codes.push(['', 'template', (slotDir.arg ?? slotDir).loc.start.offset, capabilitiesPresets.diagnosticOnly], `(${componentCtxVar}.slots!)`, ...((slotDir?.arg?.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */ && slotDir.arg.content)
                 ? createPropertyAccessCode([
                     slotDir.arg.loc.source,
                     'template',

package/out/languageModule.d.ts

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

package/out/languageModule.js

@@ -6,16 +6,16 @@ const plugins_1 = require("./plugins");
 const sourceFile_1 = require("./sourceFile");
 const sharedTypes = require("./utils/directorySharedTypes");
 const ts_1 = require("./utils/ts");
-function createLanguage(compilerOptions = {}, vueCompilerOptions = (0, ts_1.resolveVueCompilerOptions)({}), ts = require('typescript')) {
+function createLanguage(compilerOptions = {}, vueCompilerOptions = (0, ts_1.resolveVueCompilerOptions)({}), ts = require('typescript'), codegenStack = false) {
     patchResolveModuleNames(ts, vueCompilerOptions);
-    const vueLanguagePlugin = (0, plugins_1.getDefaultVueLanguagePlugins)(ts, compilerOptions, vueCompilerOptions);
+    const vueLanguagePlugin = (0, plugins_1.getDefaultVueLanguagePlugins)(ts, compilerOptions, vueCompilerOptions, codegenStack);
     const sharedTypesSnapshot = ts.ScriptSnapshot.fromString(sharedTypes.getTypesCode(vueCompilerOptions));
     const languageModule = {
         createVirtualFile(fileName, snapshot, languageId) {
             if (languageId === 'vue'
                 || (!languageId
                     && vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext)))) {
-                return new sourceFile_1.VueFile(fileName, snapshot, ts, vueLanguagePlugin);
+                return new sourceFile_1.VueFile(fileName, snapshot, vueCompilerOptions, vueLanguagePlugin, ts, codegenStack);
             }
         },
         updateVirtualFile(sourceFile, snapshot) {
@@ -63,9 +63,9 @@ function createLanguage(compilerOptions = {}, vueCompilerOptions = (0, ts_1.reso
     }
 }
 exports.createLanguage = createLanguage;
-function createLanguages(compilerOptions = {}, vueCompilerOptions = (0, ts_1.resolveVueCompilerOptions)({}), ts = require('typescript')) {
+function createLanguages(compilerOptions = {}, vueCompilerOptions = (0, ts_1.resolveVueCompilerOptions)({}), ts = require('typescript'), codegenStack = false) {
     return [
-        createLanguage(compilerOptions, vueCompilerOptions, ts),
+        createLanguage(compilerOptions, vueCompilerOptions, ts, codegenStack),
         ...vueCompilerOptions.experimentalAdditionalLanguageModules?.map(module => require(module)) ?? [],
     ];
 }

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

@@ -1,14 +1,3 @@
-import { Sfc, VueLanguagePlugin } from '../types';
-import { TextRange } from '../types';
+import { VueLanguagePlugin } from '../types';
 declare const plugin: VueLanguagePlugin;
 export default plugin;
-export declare function collectStyleCssClasses(sfc: Sfc, condition: (style: Sfc['styles'][number]) => boolean): {
-    style: (typeof sfc.styles)[number];
-    index: number;
-    classNameRanges: TextRange[];
-    classNames: string[];
-}[];
-export declare function collectCssVars(sfc: Sfc): {
-    style: (typeof sfc.styles)[number];
-    ranges: TextRange[];
-}[];

package/out/plugins/vue-tsx.js

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectCssVars = exports.collectStyleCssClasses = void 0;
 const reactivity_1 = require("@vue/reactivity");
 const script_1 = require("../generators/script");
 const templateGen = require("../generators/template");
 const scriptRanges_1 = require("../parsers/scriptRanges");
 const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
 const language_core_1 = require("@volar/language-core");
-const parseCssClassNames_1 = require("../utils/parseCssClassNames");
-const parseCssVars_1 = require("../utils/parseCssVars");
 const sharedTypes = require("../utils/directorySharedTypes");
-const plugin = ({ modules, vueCompilerOptions, compilerOptions }) => {
+const muggle = require("muggle-string");
+const plugin = ({ modules, vueCompilerOptions, compilerOptions, codegenStack }) => {
     const ts = modules.typescript;
     const instances = new WeakMap();
     const sharedTypesImport = sharedTypes.getImportName(compilerOptions);
@@ -41,7 +39,9 @@ const plugin = ({ modules, vueCompilerOptions, compilerOptions }) => {
                 };
                 const tsx = _tsx.tsxGen.value;
                 if (tsx) {
-                    embeddedFile.content = [...tsx.codes];
+                    const [content, contentStacks] = codegenStack ? muggle.track([...tsx.codes], [...tsx.codeStacks]) : [[...tsx.codes], [...tsx.codeStacks]];
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
                     embeddedFile.mirrorBehaviorMappings = [...tsx.mirrorBehaviorMappings];
                 }
             }
@@ -56,16 +56,18 @@ const plugin = ({ modules, vueCompilerOptions, compilerOptions }) => {
                     inlayHint: false,
                 };
                 if (_tsx.htmlGen.value) {
-                    embeddedFile.content = [..._tsx.htmlGen.value.formatCodes];
+                    const [content, contentStacks] = codegenStack ? muggle.track([..._tsx.htmlGen.value.formatCodes], [..._tsx.htmlGen.value.formatCodeStacks]) : [[..._tsx.htmlGen.value.formatCodes], [..._tsx.htmlGen.value.formatCodeStacks]];
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
                 }
-                for (const cssVar of _tsx.cssVars.value) {
+                for (const style of sfc.styles) {
                     embeddedFile.content.push('\n\n');
-                    for (const range of cssVar.ranges) {
+                    for (const cssVar of style.cssVars) {
                         embeddedFile.content.push('(');
                         embeddedFile.content.push([
-                            cssVar.style.content.substring(range.start, range.end),
-                            cssVar.style.name,
-                            range.start,
+                            cssVar.text,
+                            style.name,
+                            cssVar.offset,
                             {},
                         ]);
                         embeddedFile.content.push(');\n');
@@ -75,7 +77,9 @@ const plugin = ({ modules, vueCompilerOptions, compilerOptions }) => {
             else if (suffix.match(/^\.template_style\.css$/)) {
                 embeddedFile.parentFileName = fileName + '.template.' + sfc.template?.lang;
                 if (_tsx.htmlGen.value) {
-                    embeddedFile.content = [..._tsx.htmlGen.value.cssCodes];
+                    const [content, contentStacks] = codegenStack ? muggle.track([..._tsx.htmlGen.value.cssCodes], [..._tsx.htmlGen.value.cssCodeStacks]) : [[..._tsx.htmlGen.value.cssCodes], [..._tsx.htmlGen.value.cssCodeStacks]];
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
                 }
                 // for color pickers support
                 embeddedFile.capabilities.documentSymbol = true;
@@ -95,64 +99,28 @@ const plugin = ({ modules, vueCompilerOptions, compilerOptions }) => {
                     : _sfc.script && _sfc.script.lang !== 'js' ? _sfc.script.lang
                         : 'js';
         });
-        const cssVars = (0, reactivity_1.computed)(() => collectCssVars(_sfc));
         const scriptRanges = (0, reactivity_1.computed)(() => _sfc.scriptAst
             ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.scriptAst, !!_sfc.scriptSetup, false)
             : undefined);
         const scriptSetupRanges = (0, reactivity_1.computed)(() => _sfc.scriptSetupAst
             ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetupAst, vueCompilerOptions)
             : undefined);
-        const cssModuleClasses = (0, reactivity_1.computed)(() => collectStyleCssClasses(_sfc, style => !!style.module));
-        const cssScopedClasses = (0, reactivity_1.computed)(() => collectStyleCssClasses(_sfc, style => {
-            const setting = vueCompilerOptions.experimentalResolveStyleCssClasses;
-            return (setting === 'scoped' && style.scoped) || setting === 'always';
-        }));
         const htmlGen = (0, reactivity_1.computed)(() => {
             if (!_sfc.templateAst)
                 return;
-            return templateGen.generate(ts, compilerOptions, vueCompilerOptions, _sfc.template?.content ?? '', _sfc.template?.lang ?? 'html', _sfc.templateAst, hasScriptSetupSlots.value, sharedTypesImport, Object.values(cssScopedClasses.value).map(style => style.classNames).flat());
+            return templateGen.generate(ts, compilerOptions, vueCompilerOptions, _sfc.template?.content ?? '', _sfc.template?.lang ?? 'html', _sfc, hasScriptSetupSlots.value, sharedTypesImport, codegenStack);
         });
         const hasScriptSetupSlots = (0, reactivity_1.shallowRef)(false); // remove when https://github.com/vuejs/core/pull/5912 merged
         const tsxGen = (0, reactivity_1.computed)(() => {
             hasScriptSetupSlots.value = !!scriptSetupRanges.value?.slotsTypeArg;
-            return (0, script_1.generate)(ts, fileName, _sfc, lang.value, scriptRanges.value, scriptSetupRanges.value, cssVars.value, cssModuleClasses.value, cssScopedClasses.value, htmlGen.value, compilerOptions, vueCompilerOptions, sharedTypesImport);
+            return (0, script_1.generate)(ts, fileName, _sfc, lang.value, scriptRanges.value, scriptSetupRanges.value, htmlGen.value, compilerOptions, vueCompilerOptions, sharedTypesImport, codegenStack);
         });
         return {
             lang,
             tsxGen,
             htmlGen,
-            cssVars,
         };
     }
 };
 exports.default = plugin;
-function collectStyleCssClasses(sfc, condition) {
-    const result = [];
-    for (let i = 0; i < sfc.styles.length; i++) {
-        const style = sfc.styles[i];
-        if (condition(style)) {
-            const classNameRanges = [...(0, parseCssClassNames_1.parseCssClassNames)(style.content)];
-            result.push({
-                style: style,
-                index: i,
-                classNameRanges: classNameRanges,
-                classNames: classNameRanges.map(range => style.content.substring(range.start + 1, range.end)),
-            });
-        }
-    }
-    return result;
-}
-exports.collectStyleCssClasses = collectStyleCssClasses;
-function collectCssVars(sfc) {
-    const result = [];
-    for (let i = 0; i < sfc.styles.length; i++) {
-        const style = sfc.styles[i];
-        result.push({
-            style,
-            ranges: [...(0, parseCssVars_1.parseCssVars)(style.content)],
-        });
-    }
-    return result;
-}
-exports.collectCssVars = collectCssVars;
 //# sourceMappingURL=vue-tsx.js.map

package/out/plugins.d.ts

@@ -1,7 +1,7 @@
 import type * as ts from 'typescript/lib/tsserverlibrary';
 import { VueCompilerOptions } from './types';
 import * as CompilerDOM from '@vue/compiler-dom';
-export declare function getDefaultVueLanguagePlugins(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): {
+export declare function getDefaultVueLanguagePlugins(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack: boolean): {
     version: 1;
     name?: string | undefined;
     order?: number | undefined;

package/out/plugins.js

@@ -12,7 +12,7 @@ const useHtmlTemplatePlugin = require("./plugins/vue-template-html");
 const vue_tsx_1 = require("./plugins/vue-tsx");
 const CompilerDOM = require("@vue/compiler-dom");
 const CompilerVue2 = require("./utils/vue2TemplateCompiler");
-function getDefaultVueLanguagePlugins(ts, compilerOptions, vueCompilerOptions) {
+function getDefaultVueLanguagePlugins(ts, compilerOptions, vueCompilerOptions, codegenStack) {
     const plugins = [
         useMdFilePlugin,
         useHtmlFilePlugin,
@@ -32,6 +32,7 @@ function getDefaultVueLanguagePlugins(ts, compilerOptions, vueCompilerOptions) {
         },
         compilerOptions,
         vueCompilerOptions,
+        codegenStack,
     };
     const pluginInstances = plugins
         .map(plugin => plugin(pluginCtx))

package/out/sourceFile.d.ts

@@ -1,24 +1,28 @@
 import { FileCapabilities, VirtualFile, FileKind, FileRangeCapabilities, MirrorBehaviorCapabilities } from '@volar/language-core';
-import { Mapping, Segment } from '@volar/source-map';
+import { Mapping, Segment, StackNode, Stack } from '@volar/source-map';
 import * as CompilerDom from '@vue/compiler-dom';
-import { SFCBlock, SFCParseResult, SFCScriptBlock, SFCStyleBlock, SFCTemplateBlock } from '@vue/compiler-sfc';
+import type { SFCBlock, SFCParseResult, SFCScriptBlock, SFCStyleBlock, SFCTemplateBlock } from '@vue/compiler-sfc';
 import { ComputedRef } from '@vue/reactivity';
 import type * as ts from 'typescript/lib/tsserverlibrary';
 import { Sfc, SfcBlock, VueLanguagePlugin } from './types';
+import { VueCompilerOptions } from './types';
 export declare class VueEmbeddedFile {
     fileName: string;
+    content: Segment<FileRangeCapabilities>[];
+    contentStacks: StackNode[];
     parentFileName?: string;
     kind: FileKind;
     capabilities: FileCapabilities;
-    content: Segment<FileRangeCapabilities>[];
     mirrorBehaviorMappings: Mapping<[MirrorBehaviorCapabilities, MirrorBehaviorCapabilities]>[];
-    constructor(fileName: string);
+    constructor(fileName: string, content: Segment<FileRangeCapabilities>[], contentStacks: StackNode[]);
 }
 export declare class VueFile implements VirtualFile {
     fileName: string;
     snapshot: ts.IScriptSnapshot;
-    private ts;
-    private plugins;
+    vueCompilerOptions: VueCompilerOptions;
+    plugins: ReturnType<VueLanguagePlugin>[];
+    ts: typeof import('typescript/lib/tsserverlibrary');
+    codegenStack: boolean;
     parsedSfcCache: {
         snapshot: ts.IScriptSnapshot;
         sfc: SFCParseResult;
@@ -33,6 +37,7 @@ export declare class VueFile implements VirtualFile {
     capabilities: FileCapabilities;
     kind: FileKind;
     mappings: Mapping<FileRangeCapabilities>[];
+    codegenStacks: Stack[];
     get compiledSFCTemplate(): {
         errors: CompilerDom.CompilerError[];
         warnings: CompilerDom.CompilerError[];
@@ -40,7 +45,6 @@ export declare class VueFile implements VirtualFile {
     } | undefined;
     get mainScriptName(): string;
     get embeddedFiles(): VirtualFile[];
-    parsedSfc: SFCParseResult | undefined;
     sfc: Sfc;
     _sfcBlocks: ComputedRef<Record<string, SfcBlock>>;
     _compiledSfcTemplate: ComputedRef<{
@@ -52,20 +56,22 @@ export declare class VueFile implements VirtualFile {
         file: VueEmbeddedFile;
         snapshot: ts.IScriptSnapshot;
         mappings: Mapping<FileRangeCapabilities>[];
+        codegenStacks: Stack[];
     }[]>[];
     _allEmbeddedFiles: ComputedRef<{
         file: VueEmbeddedFile;
         snapshot: ts.IScriptSnapshot;
         mappings: Mapping<FileRangeCapabilities>[];
+        codegenStacks: Stack[];
     }[]>;
     _embeddedFiles: ComputedRef<VirtualFile[]>;
-    constructor(fileName: string, snapshot: ts.IScriptSnapshot, ts: typeof import('typescript/lib/tsserverlibrary'), plugins: ReturnType<VueLanguagePlugin>[]);
+    constructor(fileName: string, snapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: ReturnType<VueLanguagePlugin>[], ts: typeof import('typescript/lib/tsserverlibrary'), codegenStack: boolean);
     update(newScriptSnapshot: ts.IScriptSnapshot): void;
     parseSfc(): SFCParseResult | undefined;
-    updateTemplate(block: SFCTemplateBlock | null): void;
-    updateScript(block: SFCScriptBlock | null): void;
-    updateScriptSetup(block: SFCScriptBlock | null): void;
-    updateStyles(blocks: SFCStyleBlock[]): void;
-    updateCustomBlocks(blocks: SFCBlock[]): void;
-    updateBlock<T extends object>(oldBlock: T, newBlock: T): void;
+    parseTemplateBlock(block: SFCTemplateBlock): NonNullable<Sfc['template']>;
+    parseScriptBlock(block: SFCScriptBlock): NonNullable<Sfc['script']>;
+    parseScriptSetupBlock(block: SFCScriptBlock): NonNullable<Sfc['scriptSetup']>;
+    parseStyleBlock(block: SFCStyleBlock, i: number): Sfc['styles'][number];
+    parseCustomBlock(block: SFCBlock, i: number): Sfc['customBlocks'][number];
+    parseBlock(block: SFCBlock): Omit<SfcBlock, 'name' | 'lang'>;
 }

package/out/sourceFile.js

@@ -5,12 +5,15 @@ const language_core_1 = require("@volar/language-core");
 const source_map_1 = require("@volar/source-map");
 const reactivity_1 = require("@vue/reactivity");
 const muggle = require("muggle-string");
+const parseCssVars_1 = require("./utils/parseCssVars");
+const parseCssClassNames_1 = require("./utils/parseCssClassNames");
 class VueEmbeddedFile {
-    constructor(fileName) {
+    constructor(fileName, content, contentStacks) {
         this.fileName = fileName;
+        this.content = content;
+        this.contentStacks = contentStacks;
         this.kind = language_core_1.FileKind.TextFile;
         this.capabilities = {};
-        this.content = [];
         this.mirrorBehaviorMappings = [];
     }
 }
@@ -25,15 +28,17 @@ class VueFile {
     get embeddedFiles() {
         return this._embeddedFiles.value;
     }
-    // functions
-    constructor(fileName, snapshot, ts, plugins) {
+    constructor(fileName, snapshot, vueCompilerOptions, plugins, ts, codegenStack) {
         this.fileName = fileName;
         this.snapshot = snapshot;
-        this.ts = ts;
+        this.vueCompilerOptions = vueCompilerOptions;
         this.plugins = plugins;
+        this.ts = ts;
+        this.codegenStack = codegenStack;
         this.capabilities = language_core_1.FileCapabilities.full;
         this.kind = language_core_1.FileKind.TextFile;
         this.mappings = [];
+        this.codegenStacks = [];
         // refs
         this.sfc = (0, reactivity_1.reactive)({
             template: null,
@@ -54,12 +59,6 @@ class VueFile {
                     return this.ts.createSourceFile(this.fileName + '.' + this.sfc.scriptSetup.lang, this.sfc.scriptSetup.content, this.ts.ScriptTarget.Latest);
                 }
             }),
-            ...{
-                // backward compatible
-                getTemplateAst: () => {
-                    return this.compiledSFCTemplate?.ast;
-                },
-            },
         }) /* avoid Sfc unwrap in .d.ts by reactive */;
         // computed
         this._sfcBlocks = (0, reactivity_1.computed)(() => {
@@ -171,7 +170,8 @@ class VueFile {
                         for (const embeddedFileName of embeddedFileNames) {
                             if (!embeddedFiles[embeddedFileName]) {
                                 embeddedFiles[embeddedFileName] = (0, reactivity_1.computed)(() => {
-                                    const file = new VueEmbeddedFile(embeddedFileName);
+                                    const [content, stacks] = this.codegenStack ? muggle.track([]) : [[], []];
+                                    const file = new VueEmbeddedFile(embeddedFileName, content, stacks);
                                     for (const plugin of this.plugins) {
                                         if (plugin.resolveEmbeddedFile) {
                                             try {
@@ -182,7 +182,45 @@ class VueFile {
                                             }
                                         }
                                     }
-                                    return file;
+                                    const newText = (0, source_map_1.toString)(file.content);
+                                    const changeRanges = new Map();
+                                    const snapshot = {
+                                        getText: (start, end) => newText.slice(start, end),
+                                        getLength: () => newText.length,
+                                        getChangeRange(oldSnapshot) {
+                                            if (!changeRanges.has(oldSnapshot)) {
+                                                changeRanges.set(oldSnapshot, undefined);
+                                                const oldText = oldSnapshot.getText(0, oldSnapshot.getLength());
+                                                for (let start = 0; start < oldText.length && start < newText.length; start++) {
+                                                    if (oldText[start] !== newText[start]) {
+                                                        let end = oldText.length;
+                                                        for (let i = 0; i < oldText.length - start && i < newText.length - start; i++) {
+                                                            if (oldText[oldText.length - i - 1] !== newText[newText.length - i - 1]) {
+                                                                break;
+                                                            }
+                                                            end--;
+                                                        }
+                                                        let length = end - start;
+                                                        let newLength = length + (newText.length - oldText.length);
+                                                        if (newLength < 0) {
+                                                            length -= newLength;
+                                                            newLength = 0;
+                                                        }
+                                                        changeRanges.set(oldSnapshot, {
+                                                            span: { start, length },
+                                                            newLength,
+                                                        });
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            return changeRanges.get(oldSnapshot);
+                                        },
+                                    };
+                                    return {
+                                        file,
+                                        snapshot,
+                                    };
                                 });
                             }
                         }
@@ -195,7 +233,8 @@ class VueFile {
             });
             return (0, reactivity_1.computed)(() => {
                 return files.value.map(_file => {
-                    const file = _file.value;
+                    const file = _file.value.file;
+                    const snapshot = _file.value.snapshot;
                     const mappings = (0, source_map_1.buildMappings)(file.content);
                     for (const mapping of mappings) {
                         if (mapping.source !== undefined) {
@@ -205,49 +244,18 @@ class VueFile {
                                     mapping.sourceRange[0] + block.startTagEnd,
                                     mapping.sourceRange[1] + block.startTagEnd,
                                 ];
-                                mapping.source = undefined;
                             }
+                            else {
+                                // ignore
+                            }
+                            mapping.source = undefined;
                         }
                     }
-                    const newText = (0, source_map_1.toString)(file.content);
-                    const changeRanges = new Map();
-                    const snapshot = {
-                        getText: (start, end) => newText.slice(start, end),
-                        getLength: () => newText.length,
-                        getChangeRange(oldSnapshot) {
-                            if (!changeRanges.has(oldSnapshot)) {
-                                changeRanges.set(oldSnapshot, undefined);
-                                const oldText = oldSnapshot.getText(0, oldSnapshot.getLength());
-                                for (let start = 0; start < oldText.length && start < newText.length; start++) {
-                                    if (oldText[start] !== newText[start]) {
-                                        let end = oldText.length;
-                                        for (let i = 0; i < oldText.length - start && i < newText.length - start; i++) {
-                                            if (oldText[oldText.length - i - 1] !== newText[newText.length - i - 1]) {
-                                                break;
-                                            }
-                                            end--;
-                                        }
-                                        let length = end - start;
-                                        let newLength = length + (newText.length - oldText.length);
-                                        if (newLength < 0) {
-                                            length -= newLength;
-                                            newLength = 0;
-                                        }
-                                        changeRanges.set(oldSnapshot, {
-                                            span: { start, length },
-                                            newLength,
-                                        });
-                                        break;
-                                    }
-                                }
-                            }
-                            return changeRanges.get(oldSnapshot);
-                        },
-                    };
                     return {
                         file,
                         snapshot,
                         mappings,
+                        codegenStacks: (0, source_map_1.buildStacks)(file.content, file.contentStacks),
                     };
                 });
             });
@@ -271,11 +279,12 @@ class VueFile {
                     break;
                 }
             }
-            for (const { file, snapshot, mappings } of remain) {
+            for (const { file, snapshot, mappings, codegenStacks } of remain) {
                 embeddedFiles.push({
                     ...file,
                     snapshot,
                     mappings,
+                    codegenStacks,
                     embeddedFiles: [],
                 });
                 console.error('Unable to resolve embedded: ' + file.parentFileName + ' -> ' + file.fileName);
@@ -283,12 +292,13 @@ class VueFile {
             return embeddedFiles;
             function consumeRemain() {
                 for (let i = remain.length - 1; i >= 0; i--) {
-                    const { file, snapshot, mappings } = remain[i];
+                    const { file, snapshot, mappings, codegenStacks } = remain[i];
                     if (!file.parentFileName) {
                         embeddedFiles.push({
                             ...file,
                             snapshot,
                             mappings,
+                            codegenStacks,
                             embeddedFiles: [],
                         });
                         remain.splice(i, 1);
@@ -300,6 +310,7 @@ class VueFile {
                                 ...file,
                                 snapshot,
                                 mappings,
+                                codegenStacks,
                                 embeddedFiles: [],
                             });
                             remain.splice(i, 1);
@@ -323,21 +334,17 @@ class VueFile {
     }
     update(newScriptSnapshot) {
         this.snapshot = newScriptSnapshot;
-        this.parsedSfc = this.parseSfc();
-        if (this.parsedSfc) {
-            this.updateTemplate(this.parsedSfc.descriptor.template);
-            this.updateScript(this.parsedSfc.descriptor.script);
-            this.updateScriptSetup(this.parsedSfc.descriptor.scriptSetup);
-            this.updateStyles(this.parsedSfc.descriptor.styles);
-            this.updateCustomBlocks(this.parsedSfc.descriptor.customBlocks);
-        }
-        else {
-            this.updateTemplate(null);
-            this.updateScript(null);
-            this.updateScriptSetup(null);
-            this.updateStyles([]);
-            this.updateCustomBlocks([]);
-        }
+        const parsedSfc = this.parseSfc();
+        updateObj(this.sfc, {
+            template: parsedSfc?.descriptor.template ? this.parseTemplateBlock(parsedSfc.descriptor.template) : null,
+            script: parsedSfc?.descriptor.script ? this.parseScriptBlock(parsedSfc.descriptor.script) : null,
+            scriptSetup: parsedSfc?.descriptor.scriptSetup ? this.parseScriptSetupBlock(parsedSfc.descriptor.scriptSetup) : null,
+            styles: parsedSfc?.descriptor.styles.map(this.parseStyleBlock.bind(this)) ?? [],
+            customBlocks: parsedSfc?.descriptor.customBlocks.map(this.parseCustomBlock.bind(this)) ?? [],
+            templateAst: '__IGNORE__',
+            scriptAst: '__IGNORE__',
+            scriptSetupAst: '__IGNORE__',
+        });
         const str = [[this.snapshot.getText(0, this.snapshot.getLength()), undefined, 0, language_core_1.FileRangeCapabilities.full]];
         for (const block of [
             this.sfc.script,
@@ -399,130 +406,95 @@ class VueFile {
             }
         }
     }
-    updateTemplate(block) {
-        const newData = block ? {
+    parseTemplateBlock(block) {
+        return {
+            ...this.parseBlock(block),
             name: 'template',
-            start: this.snapshot.getText(0, block.loc.start.offset).lastIndexOf('<' + block.type),
-            end: block.loc.end.offset + this.snapshot.getText(block.loc.end.offset, this.snapshot.getLength()).indexOf('>') + 1,
-            startTagEnd: block.loc.start.offset,
-            endTagStart: block.loc.end.offset,
-            content: block.content,
             lang: block.lang ?? 'html',
-            attrs: block.attrs,
-        } : null;
-        if (this.sfc.template && newData) {
-            this.updateBlock(this.sfc.template, newData);
-        }
-        else {
-            this.sfc.template = newData;
-        }
+        };
     }
-    updateScript(block) {
-        const newData = block ? {
+    parseScriptBlock(block) {
+        return {
+            ...this.parseBlock(block),
             name: 'script',
-            start: this.snapshot.getText(0, block.loc.start.offset).lastIndexOf('<' + block.type),
-            end: block.loc.end.offset + this.snapshot.getText(block.loc.end.offset, this.snapshot.getLength()).indexOf('>') + 1,
-            startTagEnd: block.loc.start.offset,
-            endTagStart: block.loc.end.offset,
-            content: block.content,
             lang: block.lang ?? 'js',
             src: block.src,
             srcOffset: block.src ? this.snapshot.getText(0, block.loc.start.offset).lastIndexOf(block.src) - block.loc.start.offset : -1,
-            attrs: block.attrs,
-        } : null;
-        if (this.sfc.script && newData) {
-            this.updateBlock(this.sfc.script, newData);
-        }
-        else {
-            this.sfc.script = newData;
-        }
+        };
     }
-    updateScriptSetup(block) {
-        const newData = block ? {
+    parseScriptSetupBlock(block) {
+        return {
+            ...this.parseBlock(block),
             name: 'scriptSetup',
+            lang: block.lang ?? 'js',
+            generic: typeof block.attrs.generic === 'string' ? block.attrs.generic : undefined,
+            genericOffset: typeof block.attrs.generic === 'string' ? this.snapshot.getText(0, block.loc.start.offset).lastIndexOf(block.attrs.generic) - block.loc.start.offset : -1,
+        };
+    }
+    parseStyleBlock(block, i) {
+        const setting = this.vueCompilerOptions.experimentalResolveStyleCssClasses;
+        const shouldParseClassNames = block.module || (setting === 'scoped' && block.scoped) || setting === 'always';
+        return {
+            ...this.parseBlock(block),
+            name: 'style_' + i,
+            lang: block.lang ?? 'css',
+            module: typeof block.module === 'string' ? block.module : block.module ? '$style' : undefined,
+            scoped: !!block.scoped,
+            cssVars: [...(0, parseCssVars_1.parseCssVars)(block.content)],
+            classNames: shouldParseClassNames ? [...(0, parseCssClassNames_1.parseCssClassNames)(block.content)] : [],
+        };
+    }
+    parseCustomBlock(block, i) {
+        return {
+            ...this.parseBlock(block),
+            name: 'customBlock_' + i,
+            lang: block.lang ?? 'txt',
+            type: block.type,
+        };
+    }
+    parseBlock(block) {
+        return {
             start: this.snapshot.getText(0, block.loc.start.offset).lastIndexOf('<' + block.type),
             end: block.loc.end.offset + this.snapshot.getText(block.loc.end.offset, this.snapshot.getLength()).indexOf('>') + 1,
             startTagEnd: block.loc.start.offset,
             endTagStart: block.loc.end.offset,
             content: block.content,
-            lang: block.lang ?? 'js',
-            generic: typeof block.attrs.generic === 'string' ? block.attrs.generic : undefined,
-            genericOffset: typeof block.attrs.generic === 'string' ? this.snapshot.getText(0, block.loc.start.offset).lastIndexOf(block.attrs.generic) - block.loc.start.offset : -1,
             attrs: block.attrs,
-        } : null;
-        if (this.sfc.scriptSetup && newData) {
-            this.updateBlock(this.sfc.scriptSetup, newData);
-        }
-        else {
-            this.sfc.scriptSetup = newData;
-        }
+        };
     }
-    updateStyles(blocks) {
-        for (let i = 0; i < blocks.length; i++) {
-            const block = blocks[i];
-            const newData = {
-                name: 'style_' + i,
-                start: this.snapshot.getText(0, block.loc.start.offset).lastIndexOf('<' + block.type),
-                end: block.loc.end.offset + this.snapshot.getText(block.loc.end.offset, this.snapshot.getLength()).indexOf('>') + 1,
-                startTagEnd: block.loc.start.offset,
-                endTagStart: block.loc.end.offset,
-                content: block.content,
-                lang: block.lang ?? 'css',
-                module: typeof block.module === 'string' ? block.module : block.module ? '$style' : undefined,
-                scoped: !!block.scoped,
-                attrs: block.attrs,
-            };
-            if (this.sfc.styles.length > i) {
-                this.updateBlock(this.sfc.styles[i], newData);
+}
+exports.VueFile = VueFile;
+function updateObj(oldObj, newObj) {
+    if (Array.isArray(oldObj) && Array.isArray(newObj)) {
+        for (let i = 0; i < newObj.length; i++) {
+            if (oldObj.length > i) {
+                updateObj(oldObj[i], newObj[i]);
             }
             else {
-                this.sfc.styles.push(newData);
+                oldObj.push(newObj[i]);
             }
         }
-        while (this.sfc.styles.length > blocks.length) {
-            this.sfc.styles.pop();
+        if (oldObj.length > newObj.length) {
+            oldObj.splice(newObj.length, oldObj.length - newObj.length);
         }
     }
-    updateCustomBlocks(blocks) {
-        for (let i = 0; i < blocks.length; i++) {
-            const block = blocks[i];
-            const newData = {
-                name: 'customBlock_' + i,
-                start: this.snapshot.getText(0, block.loc.start.offset).lastIndexOf('<' + block.type),
-                end: block.loc.end.offset + this.snapshot.getText(block.loc.end.offset, this.snapshot.getLength()).indexOf('>') + 1,
-                startTagEnd: block.loc.start.offset,
-                endTagStart: block.loc.end.offset,
-                content: block.content,
-                lang: block.lang ?? 'txt',
-                type: block.type,
-                attrs: block.attrs,
-            };
-            if (this.sfc.customBlocks.length > i) {
-                this.updateBlock(this.sfc.customBlocks[i], newData);
+    else {
+        for (const key in newObj) {
+            if (newObj[key] === '__IGNORE__') {
+                continue;
             }
-            else {
-                this.sfc.customBlocks.push(newData);
-            }
-        }
-        while (this.sfc.customBlocks.length > blocks.length) {
-            this.sfc.customBlocks.pop();
-        }
-    }
-    updateBlock(oldBlock, newBlock) {
-        for (const key in newBlock) {
-            if (typeof oldBlock[key] === 'object' && typeof newBlock[key] === 'object') {
-                this.updateBlock(oldBlock[key], newBlock[key]);
+            else if (oldObj[key] !== null && newObj[key] !== null && typeof oldObj[key] === 'object' && typeof newObj[key] === 'object') {
+                updateObj(oldObj[key], newObj[key]);
             }
             else {
-                oldBlock[key] = newBlock[key];
+                oldObj[key] = newObj[key];
             }
         }
-        for (const key in oldBlock) {
-            if (!(key in newBlock)) {
-                delete oldBlock[key];
+        for (const key in oldObj) {
+            if (!(key in newObj)) {
+                delete oldObj[key];
             }
         }
     }
 }
-exports.VueFile = VueFile;
 //# sourceMappingURL=sourceFile.js.map

package/out/types.d.ts

@@ -1,12 +1,8 @@
-import * as embedded from '@volar/language-core';
-import { SFCParseResult } from '@vue/compiler-sfc';
+import type { SFCParseResult } from '@vue/compiler-sfc';
 import * as CompilerDom from '@vue/compiler-dom';
 import type * as ts from 'typescript/lib/tsserverlibrary';
 import { VueEmbeddedFile } from './sourceFile';
 export type { SFCParseResult } from '@vue/compiler-sfc';
-export interface VueLanguageServiceHost extends embedded.LanguageServiceHost {
-    getVueCompilationSettings(): VueCompilerOptions | undefined;
-}
 export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
     target?: 'auto' | 2 | 2.7 | 3 | 3.3;
     plugins?: string[];
@@ -43,6 +39,7 @@ export type VueLanguagePlugin = (ctx: {
     };
     compilerOptions: ts.CompilerOptions;
     vueCompilerOptions: VueCompilerOptions;
+    codegenStack: boolean;
 }) => {
     version: 1;
     name?: string;
@@ -86,6 +83,14 @@ export interface Sfc {
     styles: (SfcBlock & {
         module: string | undefined;
         scoped: boolean;
+        cssVars: {
+            text: string;
+            offset: number;
+        }[];
+        classNames: {
+            text: string;
+            offset: number;
+        }[];
     })[];
     customBlocks: (SfcBlock & {
         type: string;

package/out/utils/parseCssClassNames.d.ts

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

package/out/utils/parseCssClassNames.js

@@ -10,7 +10,7 @@ function* parseCssClassNames(styleContent) {
         if (match.index !== undefined) {
             const matchText = match[1];
             if (matchText !== undefined) {
-                yield { start: match.index, end: match.index + matchText.length };
+                yield { offset: match.index, text: matchText };
             }
         }
     }

package/out/utils/parseCssVars.d.ts

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

package/out/utils/parseCssVars.js

@@ -11,7 +11,7 @@ function* parseCssVars(styleContent) {
             const matchText = match[1] ?? match[2] ?? match[3];
             if (matchText !== undefined) {
                 const offset = match.index + styleContent.slice(match.index).indexOf(matchText);
-                yield { start: offset, end: offset + matchText.length };
+                yield { offset, text: matchText };
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "1.7.0",
+	"version": "1.7.3",
 	"main": "out/index.js",
 	"license": "MIT",
 	"files": [
@@ -13,17 +13,26 @@
 		"directory": "packages/vue-language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "1.5.4",
-		"@volar/source-map": "1.5.4",
-		"@vue/compiler-dom": "^3.3.0-beta.3",
-		"@vue/compiler-sfc": "^3.3.0-beta.3",
-		"@vue/reactivity": "^3.3.0-beta.3",
-		"@vue/shared": "^3.3.0-beta.3",
+		"@volar/language-core": "1.6.3",
+		"@volar/source-map": "1.6.3",
+		"@vue/compiler-dom": "^3.3.0",
+		"@vue/reactivity": "^3.3.0",
+		"@vue/shared": "^3.3.0",
 		"minimatch": "^9.0.0",
-		"muggle-string": "^0.2.2",
+		"muggle-string": "^0.3.1",
 		"vue-template-compiler": "^2.7.14"
 	},
 	"devDependencies": {
-		"@types/minimatch": "^5.1.2"
-	}
+		"@types/minimatch": "^5.1.2",
+		"@vue/compiler-sfc": "^3.3.0"
+	},
+	"peerDependencies": {
+		"typescript": "*"
+	},
+	"peerDependenciesMeta": {
+		"typescript": {
+			"optional": true
+		}
+	},
+	"gitHead": "0afe0eb39ed144513faddbfa4fddc667e8864cdf"
 }