@vue/language-core 2.1.8 → 2.2.0

package/lib/plugins/vue-template-html.js

@@ -155,6 +155,10 @@ const plugin = ({ modules }) => {
                             if (node.isStatic) {
                                 return false;
                             }
+                            else if (!node.loc.source) {
+                                // :class="..." -> :class=""
+                                return false;
+                            }
                             else {
                                 node.content = node.loc.source;
                             }
@@ -168,9 +172,9 @@ const plugin = ({ modules }) => {
                 delete loc.__endOffset;
                 if (withinChangeRange(loc)) {
                     loc.source =
-                        loc.source.substring(0, change.start - loc.start.offset)
+                        loc.source.slice(0, change.start - loc.start.offset)
                             + change.newText
-                            + loc.source.substring(change.end - loc.start.offset);
+                            + loc.source.slice(change.end - loc.start.offset);
                     loc.__endOffset = loc.end.offset;
                     loc.end.offset += lengthDiff;
                     return true;

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

@@ -39,7 +39,7 @@ function* generate(templateAst) {
                 const endCrt = prop.arg.loc.source[prop.arg.loc.source.length - 1]; // " | '
                 const start = prop.arg.loc.source.indexOf(endCrt) + 1;
                 const end = prop.arg.loc.source.lastIndexOf(endCrt);
-                const content = prop.arg.loc.source.substring(start, end);
+                const content = prop.arg.loc.source.slice(start, end);
                 yield `x { `;
                 yield [
                     content,

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("../codegen/common");
+const CompilerDOM = require("@vue/compiler-dom");
 const elementEvents_1 = require("../codegen/template/elementEvents");
 const templateChild_1 = require("../codegen/template/templateChild");
 const vFor_1 = require("../codegen/template/vFor");
-const CompilerDOM = require("@vue/compiler-dom");
+const utils_1 = require("../codegen/utils");
 const codeFeatures = {
     format: true,
 };
@@ -18,6 +18,7 @@ const formatBrackets = {
     // fix https://github.com/vuejs/language-tools/issues/2305
     curly: ['0 +', '+ 0;'],
     event: ['() => ', ';'],
+    generic: ['<', '>() => {};'],
 };
 const plugin = ctx => {
     const parseds = new WeakMap();
@@ -58,7 +59,14 @@ const plugin = ctx => {
         sfc.template.ast.children.forEach(visit);
         return data;
         function visit(node) {
-            if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+            if (node.type === CompilerDOM.NodeTypes.COMMENT) {
+                const match = node.loc.source.match(/^<!--\s*@vue-generic\b\s*\{(?<content>[^}]*)\}/);
+                if (match) {
+                    const { content } = match.groups ?? {};
+                    addFormatCodes(content, node.loc.start.offset + match[0].indexOf(content), formatBrackets.generic);
+                }
+            }
+            else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
                 for (const prop of node.props) {
                     if (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE) {
                         continue;
@@ -74,7 +82,7 @@ const plugin = ctx => {
                         && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY // style='z-index: 2' will compile to {'z-index':'2'}
                     ) {
                         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);
+                            const ast = (0, utils_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
                                 : formatBrackets.normal);
@@ -105,7 +113,7 @@ const plugin = ctx => {
                 if (leftExpressionRange && leftExpressionText && source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
                     const start = leftExpressionRange.start;
                     const end = source.loc.start.offset + source.content.length;
-                    addFormatCodes(templateContent.substring(start, end), start, formatBrackets.for);
+                    addFormatCodes(templateContent.slice(start, end), start, formatBrackets.for);
                 }
                 for (const child of node.children) {
                     visit(child);

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

@@ -1,7 +1,7 @@
 import type { Mapping } from '@volar/language-core';
 import type { Code, Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
-    scriptRanges: import("alien-signals").ISignal<{
+    scriptRanges: import("alien-signals").Computed<{
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
             args: import("../types").TextRange;
@@ -13,88 +13,107 @@ export declare const tsCodegen: WeakMap<Sfc, {
             inheritAttrsOption: string | undefined;
         }) | undefined;
         classBlockEnd: number | undefined;
-        bindings: import("../types").TextRange[];
+        bindings: {
+            range: import("../types").TextRange;
+            moduleName?: string;
+            isDefaultImport?: boolean;
+            isNamespace?: boolean;
+        }[];
     } | undefined>;
-    scriptSetupRanges: import("alien-signals").ISignal<{
+    scriptSetupRanges: import("alien-signals").Computed<{
         leadingCommentEndOffset: number;
         importSectionEndOffset: number;
-        bindings: import("../types").TextRange[];
-        importComponentNames: Set<string>;
-        props: {
+        bindings: {
+            range: import("../types").TextRange;
+            moduleName?: string;
+            isDefaultImport?: boolean;
+            isNamespace?: boolean;
+        }[];
+        defineProp: {
+            localName?: import("../types").TextRange;
+            name?: import("../types").TextRange;
+            type?: import("../types").TextRange;
+            modifierType?: import("../types").TextRange;
+            runtimeType?: import("../types").TextRange;
+            defaultValue?: import("../types").TextRange;
+            required?: boolean;
+            isModel?: boolean;
+        }[];
+        defineProps: ({
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        } & {
             name?: string;
             destructured?: Set<string>;
             destructuredRest?: string;
-            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }> & {
-                statement: import("../types").TextRange;
-            };
-            withDefaults?: import("../types").TextRange & {
-                arg?: import("../types").TextRange;
-            };
-        };
-        slots: {
-            name?: string;
-            isObjectBindingPattern?: boolean;
-            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }>;
-        };
-        emits: {
+            statement: import("../types").TextRange;
+        }) | undefined;
+        withDefaults: {
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange | undefined;
+        } | undefined;
+        defineEmits: ({
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        } & {
             name?: string;
-            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }> & {
-                statement: import("../types").TextRange;
-                hasUnionTypeArg?: boolean;
-            };
-        };
-        expose: {
+            hasUnionTypeArg?: boolean;
+            statement: import("../types").TextRange;
+        }) | undefined;
+        defineSlots: ({
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        } & {
             name?: string;
-            define?: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }>;
-        };
-        options: {
+            isObjectBindingPattern?: boolean;
+            statement: import("../types").TextRange;
+        }) | undefined;
+        defineExpose: {
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        } | undefined;
+        defineOptions: {
             name?: string;
             inheritAttrs?: string;
-        };
-        cssModules: {
-            define: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }>;
+        } | undefined;
+        useAttrs: {
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
         }[];
-        defineProp: {
-            localName: import("../types").TextRange | undefined;
-            name: import("../types").TextRange | undefined;
-            type: import("../types").TextRange | undefined;
-            modifierType?: import("../types").TextRange | undefined;
-            runtimeType: import("../types").TextRange | undefined;
-            defaultValue: import("../types").TextRange | undefined;
-            required: boolean;
-            isModel?: boolean;
+        useCssModule: {
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
         }[];
-        templateRefs: {
-            name?: string;
-            define: ReturnType<(node: import("typescript").CallExpression) => import("../types").TextRange & {
-                exp: import("../types").TextRange;
-                arg?: import("../types").TextRange;
-                typeArg?: import("../types").TextRange;
-            }>;
+        useSlots: {
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
         }[];
+        useTemplateRef: ({
+            callExp: import("../types").TextRange;
+            exp: import("../types").TextRange;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        } & {
+            name?: string;
+        })[];
     } | undefined>;
-    lang: import("alien-signals").ISignal<string>;
-    generatedScript: import("alien-signals").ISignal<{
+    lang: import("alien-signals").Computed<string>;
+    generatedScript: import("alien-signals").Computed<{
         codes: Code[];
         linkedCodeMappings: Mapping<unknown>[];
         generatedTemplate: boolean;
@@ -115,7 +134,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         };
         inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
     }>;
-    generatedTemplate: import("alien-signals").ISignal<{
+    generatedTemplate: import("alien-signals").Computed<{
         codes: Code[];
         slots: {
             name: string;
@@ -137,14 +156,18 @@ export declare const tsCodegen: WeakMap<Sfc, {
             navigationWithoutRename: import("../types").VueCodeInformation;
             navigationAndCompletion: import("../types").VueCodeInformation;
             navigationAndAdditionalCompletion: import("../types").VueCodeInformation;
+            withoutNavigation: import("../types").VueCodeInformation;
             withoutHighlight: import("../types").VueCodeInformation;
             withoutHighlightAndCompletion: import("../types").VueCodeInformation;
             withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
         };
         accessExternalVariables: Map<string, Set<number>>;
+        lastGenericComment: {
+            content: string;
+            offset: number;
+        } | undefined;
         hasSlotElements: Set<import("@vue/compiler-dom").ElementNode>;
         blockConditions: string[];
-        usedComponentCtxVars: Set<string>;
         scopedClasses: {
             source: string;
             className: string;
@@ -153,8 +176,14 @@ export declare const tsCodegen: WeakMap<Sfc, {
         emptyClassOffsets: number[];
         inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
         hasSlot: boolean;
-        inheritedAttrVars: Set<unknown>;
+        bindingAttrLocs: import("@vue/compiler-dom").SourceLocation[];
+        inheritedAttrVars: Set<string>;
         templateRefs: Map<string, [varName: string, offset: number]>;
+        currentComponent: {
+            node: import("@vue/compiler-dom").ElementNode;
+            ctxVar: string;
+            used: boolean;
+        } | undefined;
         singleRootElType: string | undefined;
         singleRootNode: import("@vue/compiler-dom").ElementNode | undefined;
         accessExternalVariable(name: string, offset?: number): void;

package/lib/plugins/vue-tsx.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
 const alien_signals_1 = require("alien-signals");
-const path_browserify_1 = require("path-browserify");
 const script_1 = require("../codegen/script");
 const template_1 = require("../codegen/template");
 const scriptRanges_1 = require("../parsers/scriptRanges");
 const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
+const vueCompilerOptions_1 = require("../parsers/vueCompilerOptions");
+const ts_1 = require("../utils/ts");
 exports.tsCodegen = new WeakMap();
 const fileEditTimes = new Map();
 const plugin = ctx => {
@@ -30,8 +31,7 @@ const plugin = ctx => {
             if (/script_(js|jsx|ts|tsx)/.test(embeddedFile.id)) {
                 const tsx = _tsx.generatedScript.get();
                 if (tsx) {
-                    const content = [...tsx.codes];
-                    embeddedFile.content = content;
+                    embeddedFile.content = [...tsx.codes];
                     embeddedFile.linkedCodeMappings = [...tsx.linkedCodeMappings];
                 }
             }
@@ -58,23 +58,75 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
                 : _sfc.script && _sfc.script.lang !== 'js' ? _sfc.script.lang
                     : 'js';
     });
+    const vueCompilerOptions = (0, alien_signals_1.computed)(() => {
+        const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(_sfc.comments);
+        return options
+            ? (0, ts_1.resolveVueCompilerOptions)(options, ctx.vueCompilerOptions)
+            : ctx.vueCompilerOptions;
+    });
     const scriptRanges = (0, alien_signals_1.computed)(() => _sfc.script
         ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.script.ast, !!_sfc.scriptSetup, false)
         : undefined);
     const scriptSetupRanges = (0, alien_signals_1.computed)(() => _sfc.scriptSetup
-        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, ctx.vueCompilerOptions)
+        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, vueCompilerOptions.get())
         : undefined);
+    const scriptSetupBindingNames = alien_signals_1.unstable.computedSet((0, alien_signals_1.computed)(() => {
+        const newNames = new Set();
+        const bindings = scriptSetupRanges.get()?.bindings;
+        if (_sfc.scriptSetup && bindings) {
+            for (const { range } of bindings) {
+                newNames.add(_sfc.scriptSetup.content.slice(range.start, range.end));
+            }
+        }
+        return newNames;
+    }));
+    const scriptSetupImportComponentNames = alien_signals_1.unstable.computedSet((0, alien_signals_1.computed)(() => {
+        const newNames = new Set();
+        const bindings = scriptSetupRanges.get()?.bindings;
+        if (_sfc.scriptSetup && bindings) {
+            for (const { range, moduleName, isDefaultImport, isNamespace } of bindings) {
+                if (moduleName
+                    && isDefaultImport
+                    && !isNamespace
+                    && ctx.vueCompilerOptions.extensions.some(ext => moduleName.endsWith(ext))) {
+                    newNames.add(_sfc.scriptSetup.content.slice(range.start, range.end));
+                }
+            }
+        }
+        return newNames;
+    }));
+    const destructuredPropNames = alien_signals_1.unstable.computedSet((0, alien_signals_1.computed)(() => {
+        const newNames = new Set(scriptSetupRanges.get()?.defineProps?.destructured);
+        const rest = scriptSetupRanges.get()?.defineProps?.destructuredRest;
+        if (rest) {
+            newNames.add(rest);
+        }
+        return newNames;
+    }));
+    const templateRefNames = alien_signals_1.unstable.computedSet((0, alien_signals_1.computed)(() => {
+        const newNames = new Set(scriptSetupRanges.get()?.useTemplateRef
+            .map(({ name }) => name)
+            .filter(name => name !== undefined));
+        return newNames;
+    }));
+    const hasDefineSlots = (0, alien_signals_1.computed)(() => !!scriptSetupRanges.get()?.defineSlots);
+    const slotsAssignName = (0, alien_signals_1.computed)(() => scriptSetupRanges.get()?.defineSlots?.name);
+    const propsAssignName = (0, alien_signals_1.computed)(() => scriptSetupRanges.get()?.defineProps?.name);
+    const inheritAttrs = (0, alien_signals_1.computed)(() => {
+        const value = scriptSetupRanges.get()?.defineOptions?.inheritAttrs ?? scriptRanges.get()?.exportDefault?.inheritAttrsOption;
+        return value !== 'false';
+    });
     const generatedTemplate = (0, alien_signals_1.computed)(() => {
-        if (ctx.vueCompilerOptions.skipTemplateCodegen || !_sfc.template) {
+        if (vueCompilerOptions.get().skipTemplateCodegen || !_sfc.template) {
             return;
         }
         const codes = [];
         const codegen = (0, template_1.generateTemplate)({
             ts,
             compilerOptions: ctx.compilerOptions,
-            vueCompilerOptions: ctx.vueCompilerOptions,
+            vueCompilerOptions: vueCompilerOptions.get(),
             template: _sfc.template,
-            edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
+            edited: vueCompilerOptions.get().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
             scriptSetupBindingNames: scriptSetupBindingNames.get(),
             scriptSetupImportComponentNames: scriptSetupImportComponentNames.get(),
             destructuredPropNames: destructuredPropNames.get(),
@@ -95,68 +147,23 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
             codes: codes,
         };
     });
-    const scriptSetupBindingNames = (0, alien_signals_1.computed)(oldNames => {
-        const newNames = new Set();
-        const bindings = scriptSetupRanges.get()?.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, alien_signals_1.computed)(oldNames => {
-        const newNames = scriptSetupRanges.get()?.importComponentNames ?? new Set();
-        if (oldNames && twoSetsEqual(newNames, oldNames)) {
-            return oldNames;
-        }
-        return newNames;
-    });
-    const destructuredPropNames = (0, alien_signals_1.computed)(oldNames => {
-        const newNames = scriptSetupRanges.get()?.props.destructured ?? new Set();
-        const rest = scriptSetupRanges.get()?.props.destructuredRest;
-        if (rest) {
-            newNames.add(rest);
-        }
-        if (oldNames && twoSetsEqual(newNames, oldNames)) {
-            return oldNames;
-        }
-        return newNames;
-    });
-    const templateRefNames = (0, alien_signals_1.computed)(oldNames => {
-        const newNames = new Set(scriptSetupRanges.get()?.templateRefs
-            .map(({ name }) => name)
-            .filter(name => name !== undefined));
-        if (oldNames && twoSetsEqual(newNames, oldNames)) {
-            return oldNames;
-        }
-        return newNames;
-    });
-    const hasDefineSlots = (0, alien_signals_1.computed)(() => !!scriptSetupRanges.get()?.slots.define);
-    const slotsAssignName = (0, alien_signals_1.computed)(() => scriptSetupRanges.get()?.slots.name);
-    const propsAssignName = (0, alien_signals_1.computed)(() => scriptSetupRanges.get()?.props.name);
-    const inheritAttrs = (0, alien_signals_1.computed)(() => {
-        const value = scriptSetupRanges.get()?.options.inheritAttrs ?? scriptRanges.get()?.exportDefault?.inheritAttrsOption;
-        return value !== 'false';
-    });
     const generatedScript = (0, alien_signals_1.computed)(() => {
         const codes = [];
         const linkedCodeMappings = [];
         let generatedLength = 0;
         const codegen = (0, script_1.generateScript)({
             ts,
-            fileBaseName: path_browserify_1.posix.basename(fileName),
+            compilerOptions: ctx.compilerOptions,
+            vueCompilerOptions: vueCompilerOptions.get(),
             sfc: _sfc,
+            edited: vueCompilerOptions.get().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
+            fileName,
             lang: lang.get(),
             scriptRanges: scriptRanges.get(),
             scriptSetupRanges: scriptSetupRanges.get(),
             templateCodegen: generatedTemplate.get(),
-            compilerOptions: ctx.compilerOptions,
-            vueCompilerOptions: ctx.vueCompilerOptions,
-            edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
+            destructuredPropNames: destructuredPropNames.get(),
+            templateRefNames: templateRefNames.get(),
             getGeneratedLength: () => generatedLength,
             linkedCodeMappings,
             appendGlobalTypes,
@@ -185,15 +192,4 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         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/types.d.ts

@@ -37,8 +37,10 @@ export interface VueCompilerOptions {
         defineOptions: string[];
         withDefaults: string[];
     };
-    composibles: {
+    composables: {
+        useAttrs: string[];
         useCssModule: string[];
+        useSlots: string[];
         useTemplateRef: string[];
     };
     plugins: VueLanguagePlugin[];
@@ -81,8 +83,8 @@ export type VueLanguagePluginReturn = {
 };
 export type VueLanguagePlugin = (ctx: {
     modules: {
-        typescript: typeof import('typescript');
-        '@vue/compiler-dom': typeof import('@vue/compiler-dom');
+        typescript: typeof ts;
+        '@vue/compiler-dom': typeof CompilerDOM;
     };
     compilerOptions: ts.CompilerOptions;
     vueCompilerOptions: VueCompilerOptions;
@@ -97,14 +99,9 @@ export interface SfcBlock {
     content: string;
     attrs: Record<string, string | true>;
 }
-export interface SFCStyleOverride {
-    module?: {
-        name: string;
-        offset?: number;
-    };
-}
 export interface Sfc {
     content: string;
+    comments: string[];
     template: SfcBlock & {
         ast: CompilerDOM.RootNode | undefined;
         errors: CompilerDOM.CompilerError[];
@@ -120,8 +117,12 @@ export interface Sfc {
         genericOffset: number;
         ast: ts.SourceFile;
     } | undefined;
-    styles: readonly (SfcBlock & SFCStyleOverride & {
+    styles: readonly (SfcBlock & {
         scoped: boolean;
+        module?: {
+            name: string;
+            offset?: number;
+        };
         cssVars: {
             text: string;
             offset: number;
@@ -135,6 +136,14 @@ export interface Sfc {
         type: string;
     })[];
 }
+declare module '@vue/compiler-sfc' {
+    interface SFCStyleBlock {
+        __module?: {
+            name: string;
+            offset?: number;
+        };
+    }
+}
 export interface TextRange {
     start: number;
     end: number;

package/lib/utils/buildMappings.d.ts

@@ -1,3 +1,3 @@
-import type { Segment } from 'muggle-string';
 import type { Mapping } from '@volar/language-core';
+import type { Segment } from 'muggle-string';
 export declare function buildMappings<T>(chunks: Segment<T>[]): Mapping<T>[];

package/lib/utils/parseSfc.d.ts

@@ -1,2 +1,7 @@
 import type { SFCParseResult } from '@vue/compiler-sfc';
+declare module '@vue/compiler-sfc' {
+    interface SFCDescriptor {
+        comments: string[];
+    }
+}
 export declare function parse(source: string): SFCParseResult;

package/lib/utils/parseSfc.js

@@ -18,6 +18,7 @@ function parse(source) {
     const descriptor = {
         filename: 'anonymous.vue',
         source,
+        comments: [],
         template: null,
         script: null,
         scriptSetup: null,
@@ -28,7 +29,11 @@ function parse(source) {
         shouldForceReload: () => false,
     };
     ast.children.forEach(node => {
-        if (node.type !== compiler.NodeTypes.ELEMENT) {
+        if (node.type === compiler.NodeTypes.COMMENT) {
+            descriptor.comments.push(node.content);
+            return;
+        }
+        else if (node.type !== compiler.NodeTypes.ELEMENT) {
             return;
         }
         switch (node.tag) {
@@ -107,7 +112,7 @@ function createBlock(node, source) {
                     block.scoped = true;
                 }
                 else if (p.name === 'module') {
-                    block.module = {
+                    block.__module = {
                         name: p.value?.content ?? '$style',
                         offset: p.value?.content ? p.value?.loc.start.offset - node.loc.start.offset : undefined
                     };

package/lib/utils/ts.d.ts

@@ -7,7 +7,7 @@ export declare function createParsedCommandLineByJson(ts: typeof import('typescr
     writeFile?(path: string, data: string): void;
 }, rootDir: string, json: any, configFileName?: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
 export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
-export declare function resolveVueCompilerOptions(vueOptions: Partial<VueCompilerOptions>): VueCompilerOptions;
+export declare function resolveVueCompilerOptions(options: Partial<VueCompilerOptions>, defaults?: VueCompilerOptions): VueCompilerOptions;
 export declare function setupGlobalTypes(rootDir: string, vueOptions: VueCompilerOptions, host: {
     fileExists(path: string): boolean;
     writeFile?(path: string, data: string): void;