@vue/language-core 2.0.26 → 2.0.28

package/index.d.ts

@@ -1,5 +1,5 @@
 export * from './lib/codegen/template';
-export * from './lib/languageModule';
+export * from './lib/languagePlugin';
 export * from './lib/parsers/scriptSetupRanges';
 export * from './lib/plugins';
 export * from './lib/virtualFile/vueFile';

package/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = exports.scriptRanges = void 0;
 __exportStar(require("./lib/codegen/template"), exports);
-__exportStar(require("./lib/languageModule"), exports);
+__exportStar(require("./lib/languagePlugin"), exports);
 __exportStar(require("./lib/parsers/scriptSetupRanges"), exports);
 __exportStar(require("./lib/plugins"), exports);
 __exportStar(require("./lib/virtualFile/vueFile"), exports);

package/lib/codegen/script/component.js

@@ -60,7 +60,7 @@ function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges) {
     if (options.vueCompilerOptions.target >= 3.5 && ctx.generatedPropsType) {
         yield `__typeProps: {} as __VLS_PublicProps,${common_1.newLine}`;
     }
-    else {
+    if (options.vueCompilerOptions.target < 3.5 || !ctx.generatedPropsType || scriptSetupRanges.props.withDefaults) {
         const codegens = [];
         if (ctx.generatedPropsType) {
             codegens.push(function* () {

package/lib/codegen/script/globalTypes.js

@@ -16,15 +16,8 @@ declare global {
         ? `import('${vueCompilerOptions.lib}/jsx-runtime').JSX.Element;`
         : `globalThis.JSX.Element;`}
 	type __VLS_GlobalComponents = ${vueCompilerOptions.target >= 3.5
-        ? `import('${vueCompilerOptions.lib}').GlobalComponents`
+        ? `import('${vueCompilerOptions.lib}').GlobalComponents;`
         : `import('${vueCompilerOptions.lib}').GlobalComponents & Pick<typeof import('${vueCompilerOptions.lib}'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;`}
-	type __VLS_BuiltInPublicProps = ${vueCompilerOptions.target >= 3.4
-        ? `import('${vueCompilerOptions.lib}').PublicProps;`
-        : vueCompilerOptions.target >= 3.0
-            ? `import('${vueCompilerOptions.lib}').VNodeProps
-					& import('${vueCompilerOptions.lib}').AllowedComponentProps
-					& import('${vueCompilerOptions.lib}').ComponentCustomProps;`
-            : `globalThis.JSX.IntrinsicAttributes;`}
 	type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
 	type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
 
@@ -64,6 +57,7 @@ declare global {
 		: T;
 	function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
 	function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
+	function __VLS_nonNullable<T>(t: T): T extends null | undefined ? never : T;
 
 	type __VLS_SelfComponent<N, C> = string extends N ? {} : N extends string ? { [P in N]: C } : {};
 	type __VLS_WithComponent<N0 extends string, LocalComponents, N1 extends string, N2 extends string, N3 extends string> =

package/lib/codegen/script/index.js

@@ -105,7 +105,17 @@ function* generateScript(options) {
         yield* generateDefineProp(options, options.sfc.scriptSetup);
         yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
     }
-    yield common_1.endOfLine;
+    yield `;`;
+    if (options.sfc.scriptSetup) {
+        // #4569
+        yield [
+            '',
+            'scriptSetup',
+            options.sfc.scriptSetup.content.length,
+            exports.codeFeatures.verification,
+        ];
+    }
+    yield common_1.newLine;
     if (options.globalTypes) {
         yield (0, globalTypes_1.generateGlobalTypes)(options.vueCompilerOptions);
     }

package/lib/codegen/script/scriptSetup.js

@@ -19,6 +19,15 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
     const definePropMirrors = new Map();
     if (scriptSetup.generic) {
         if (!options.scriptRanges?.exportDefault) {
+            if (options.sfc.scriptSetup) {
+                // #4569
+                yield [
+                    '',
+                    'scriptSetup',
+                    options.sfc.scriptSetup.content.length,
+                    index_1.codeFeatures.verification,
+                ];
+            }
             yield `export default `;
         }
         yield `(<`;
@@ -32,8 +41,8 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
             yield `,`;
         }
         yield `>(${common_1.newLine}`
-            + `	__VLS_props: Awaited<typeof __VLS_setup>['props'],${common_1.newLine}`
-            + `	__VLS_ctx?: ${ctx.helperTypes.Prettify.name}<Pick<Awaited<typeof __VLS_setup>, 'attrs' | 'emit' | 'slots'>>,${common_1.newLine}` // use __VLS_Prettify for less dts code
+            + `	__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'],${common_1.newLine}`
+            + `	__VLS_ctx?: ${ctx.helperTypes.Prettify.name}<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>,${common_1.newLine}` // use __VLS_Prettify for less dts code
             + `	__VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>['expose'],${common_1.newLine}`
             + `	__VLS_setup = (async () => {${common_1.newLine}`;
         yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, undefined, definePropMirrors);
@@ -233,6 +242,14 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
     }
     yield* (0, component_1.generateEmitsOption)(options, scriptSetup, scriptSetupRanges);
     yield `})${common_1.endOfLine}`;
+    yield `type __VLS_BuiltInPublicProps = ${options.vueCompilerOptions.target >= 3.4
+        ? `import('${options.vueCompilerOptions.lib}').PublicProps;`
+        : options.vueCompilerOptions.target >= 3.0
+            ? `import('${options.vueCompilerOptions.lib}').VNodeProps
+					& import('${options.vueCompilerOptions.lib}').AllowedComponentProps
+					& import('${options.vueCompilerOptions.lib}').ComponentCustomProps;`
+            : `globalThis.JSX.IntrinsicAttributes;`}`;
+    yield common_1.endOfLine;
     yield `let __VLS_functionalComponentProps!: `;
     yield `${ctx.helperTypes.OmitKeepDiscriminatedUnion.name}<InstanceType<typeof __VLS_fnComponent>['$props'], keyof __VLS_BuiltInPublicProps>`;
     yield common_1.endOfLine;
@@ -272,6 +289,8 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
             if (defineProp.name && defineProp.nameIsString) {
                 // renaming support
                 yield (0, common_1.generateSfcBlockSection)(scriptSetup, defineProp.name.start, defineProp.name.end, index_1.codeFeatures.navigation);
+                propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
+                propName = propName.replace(/['"]+/g, '');
             }
             else if (defineProp.name) {
                 propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
@@ -284,18 +303,7 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, d
             yield defineProp.required
                 ? `: `
                 : `?: `;
-            if (defineProp.type) {
-                yield scriptSetup.content.substring(defineProp.type.start, defineProp.type.end);
-            }
-            else if (!defineProp.nameIsString) {
-                yield `NonNullable<typeof ${propName}['value']>`;
-            }
-            else if (defineProp.defaultValue) {
-                yield `typeof __VLS_defaults['${propName}']`;
-            }
-            else {
-                yield `any`;
-            }
+            yield* generateDefinePropType(scriptSetup, propName, defineProp);
             yield `,${common_1.newLine}`;
             if (defineProp.modifierType) {
                 let propModifierName = 'modelModifiers';
@@ -339,12 +347,7 @@ function* generateModelEmits(options, scriptSetup, scriptSetupRanges) {
                 propName = propName.replace(/['"]+/g, '');
             }
             yield `'update:${propName}': [${propName}:`;
-            if (defineProp.type) {
-                yield scriptSetup.content.substring(defineProp.type.start, defineProp.type.end);
-            }
-            else {
-                yield `any`;
-            }
+            yield* generateDefinePropType(scriptSetup, propName, defineProp);
             yield `]${common_1.endOfLine}`;
         }
         yield `}`;
@@ -357,4 +360,21 @@ function* generateModelEmits(options, scriptSetup, scriptSetupRanges) {
     }
     yield common_1.endOfLine;
 }
+function* generateDefinePropType(scriptSetup, propName, defineProp) {
+    if (defineProp.type) {
+        // Infer from defineProp<T>
+        yield scriptSetup.content.substring(defineProp.type.start, defineProp.type.end);
+    }
+    else if ((defineProp.name && defineProp.nameIsString) || !defineProp.nameIsString) {
+        // Infer from actual prop declaration code 
+        yield `NonNullable<typeof ${propName}['value']>`;
+    }
+    else if (defineProp.defaultValue) {
+        // Infer from defineProp({default: T})
+        yield `typeof __VLS_defaults['${propName}']`;
+    }
+    else {
+        yield `any`;
+    }
+}
 //# sourceMappingURL=scriptSetup.js.map

package/lib/codegen/template/element.js

@@ -16,6 +16,7 @@ const elementProps_1 = require("./elementProps");
 const interpolation_1 = require("./interpolation");
 const propertyAccess_1 = require("./propertyAccess");
 const templateChild_1 = require("./templateChild");
+const objectProperty_1 = require("./objectProperty");
 const colonReg = /:/g;
 function* generateComponent(options, ctx, node, currentComponent, componentCtxVar) {
     const startTagOffset = node.loc.start.offset + options.template.content.substring(node.loc.start.offset).indexOf(node.tag);
@@ -168,6 +169,13 @@ function* generateComponent(options, ctx, node, currentComponent, componentCtxVa
     yield* generateVScope(options, ctx, node, props);
     ctx.usedComponentCtxVars.add(componentCtxVar);
     const usedComponentEventsVar = yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, var_functionalComponent, var_componentInstance, var_componentEmit, var_componentEvents);
+    if (var_defineComponentCtx && ctx.usedComponentCtxVars.has(var_defineComponentCtx)) {
+        yield `const ${componentCtxVar} = __VLS_nonNullable(__VLS_pickFunctionalComponentCtx(${var_originalComponent}, ${var_componentInstance}))${common_1.endOfLine}`;
+    }
+    if (usedComponentEventsVar) {
+        yield `let ${var_componentEmit}!: typeof ${componentCtxVar}.emit${common_1.endOfLine}`;
+        yield `let ${var_componentEvents}!: __VLS_NormalizeEmits<typeof ${var_componentEmit}>${common_1.endOfLine}`;
+    }
     const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
     if (slotDir) {
         yield* generateComponentSlot(options, ctx, node, slotDir, currentComponent, componentCtxVar);
@@ -175,13 +183,6 @@ function* generateComponent(options, ctx, node, currentComponent, componentCtxVa
     else {
         yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentComponent, componentCtxVar);
     }
-    if (var_defineComponentCtx && ctx.usedComponentCtxVars.has(var_defineComponentCtx)) {
-        yield `const ${componentCtxVar} = __VLS_pickFunctionalComponentCtx(${var_originalComponent}, ${var_componentInstance})!${common_1.endOfLine}`;
-    }
-    if (usedComponentEventsVar) {
-        yield `let ${var_componentEmit}!: typeof ${componentCtxVar}.emit${common_1.endOfLine}`;
-        yield `let ${var_componentEvents}!: __VLS_NormalizeEmits<typeof ${var_componentEmit}>${common_1.endOfLine}`;
-    }
 }
 function* generateElement(options, ctx, node, currentComponent, componentCtxVar) {
     const startTagOffset = node.loc.start.offset + options.template.content.substring(node.loc.start.offset).indexOf(node.tag);
@@ -271,11 +272,23 @@ function* generateComponentSlot(options, ctx, node, slotDir, currentComponent, c
         ctx.hasSlotElements.add(currentComponent);
     }
     const slotBlockVars = [];
-    let hasProps = false;
+    yield `const {`;
+    if (slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc);
+        yield ': __VLS_thisSlot';
+    }
+    else {
+        yield `default: `;
+        yield* (0, common_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+            ? '#'.length
+            : slotDir.loc.source.startsWith('v-slot:')
+                ? 'v-slot:'.length
+                : 0), ctx.codeFeatures.withoutHighlightAndCompletion, `__VLS_thisSlot`);
+    }
+    yield `} = __VLS_nonNullable(${componentCtxVar}.slots)${common_1.endOfLine}`;
     if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         const slotAst = (0, common_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
         (0, common_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
-        hasProps = true;
         if (!slotDir.exp.content.includes(':')) {
             yield `const [`;
             yield [
@@ -284,7 +297,7 @@ function* generateComponentSlot(options, ctx, node, slotDir, currentComponent, c
                 slotDir.exp.loc.start.offset,
                 ctx.codeFeatures.all,
             ];
-            yield `] = __VLS_getSlotParams(`;
+            yield `] = __VLS_getSlotParams(__VLS_thisSlot)${common_1.endOfLine}`;
         }
         else {
             yield `const `;
@@ -294,23 +307,9 @@ function* generateComponentSlot(options, ctx, node, slotDir, currentComponent, c
                 slotDir.exp.loc.start.offset,
                 ctx.codeFeatures.all,
             ];
-            yield ` = __VLS_getSlotParam(`;
+            yield ` = __VLS_getSlotParam(__VLS_thisSlot)${common_1.endOfLine}`;
         }
     }
-    yield* (0, common_1.wrapWith)((slotDir.arg ?? slotDir).loc.start.offset, (slotDir.arg ?? slotDir).loc.end.offset, ctx.codeFeatures.verification, `(${componentCtxVar}.slots!)`, ...(slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content
-        ? (0, propertyAccess_1.generatePropertyAccess)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc)
-        : [
-            `.`,
-            ...(0, common_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
-                ? '#'.length
-                : slotDir.loc.source.startsWith('v-slot:')
-                    ? 'v-slot:'.length
-                    : 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`)
-        ]));
-    if (hasProps) {
-        yield `)`;
-    }
-    yield common_1.endOfLine;
     for (const varName of slotBlockVars) {
         ctx.addLocalVariable(varName);
     }
@@ -328,7 +327,7 @@ function* generateComponentSlot(options, ctx, node, slotDir, currentComponent, c
         isStatic = slotDir.arg.isStatic;
     }
     if (isStatic && slotDir && !slotDir.arg) {
-        yield `${componentCtxVar}.slots!['`;
+        yield `__VLS_nonNullable(${componentCtxVar}.slots)['`;
         yield [
             '',
             'template',

package/lib/codegen/template/elementChildren.js

@@ -18,7 +18,7 @@ function* generateElementChildren(options, ctx, node, currentComponent, componen
         && node.children.length
         && node.tagType !== CompilerDOM.ElementTypes.ELEMENT
         && node.tagType !== CompilerDOM.ElementTypes.TEMPLATE) {
-        yield `(${componentCtxVar}.slots!).`;
+        yield `__VLS_nonNullable(${componentCtxVar}.slots).`;
         yield* (0, common_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
         yield common_1.endOfLine;
     }

package/lib/codegen/template/elementEvents.js

@@ -144,7 +144,7 @@ function isCompoundExpression(ts, ast) {
                     if (ts.isArrowFunction(child_2)) {
                         result = false;
                     }
-                    else if (ts.isIdentifier(child_2)) {
+                    else if (isPropertyAccessOrId(ts, child_2)) {
                         result = false;
                     }
                 });
@@ -156,4 +156,13 @@ function isCompoundExpression(ts, ast) {
     }
     return result;
 }
+function isPropertyAccessOrId(ts, node) {
+    if (ts.isIdentifier(node)) {
+        return true;
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        return isPropertyAccessOrId(ts, node.expression);
+    }
+    return false;
+}
 //# sourceMappingURL=elementEvents.js.map

package/lib/codegen/template/elementProps.js

@@ -86,7 +86,7 @@ function* generateElementProps(options, ctx, node, props, enableCodeFeatures, pr
                         }
                         : false,
                 }, prop.loc.name_2 ?? (prop.loc.name_2 = {}), shouldCamelize)
-                : [propName]), `: (`, ...genereatePropExp(options, ctx, prop.exp, ctx.codeFeatures.all, prop.arg?.loc.start.offset === prop.exp?.loc.start.offset, enableCodeFeatures), `)`);
+                : (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, ctx.codeFeatures.verification, propName)), `: (`, ...genereatePropExp(options, ctx, prop.exp, ctx.codeFeatures.all, prop.arg?.loc.start.offset === prop.exp?.loc.start.offset, enableCodeFeatures), `)`);
             if (!enableCodeFeatures) {
                 yield (0, muggle_string_1.toString)([...codes]);
             }

package/lib/codegen/template/objectKey.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/codegen/template/objectKey.js

@@ -0,0 +1,34 @@
+"use strict";
+// import type { Code, VueCodeInformation } from '../../types';
+// import type { TemplateCodegenContext } from './context';
+// import type { TemplateCodegenOptions } from './index';
+// import { generateInterpolation } from './interpolation';
+// import { generateStringLiteralKey } from './stringLiteralKey';
+Object.defineProperty(exports, "__esModule", { value: true });
+// export function* generateObjectKey(
+// 	options: TemplateCodegenOptions,
+// 	ctx: TemplateCodegenContext,
+// 	code: string,
+// 	offset: number,
+// 	features: VueCodeInformation,
+// 	astHolder?: any
+// ): Generator<Code> {
+// 	yield `[`;
+// 	if (code.startsWith('[') && code.endsWith(']')) {
+// 		yield* generateInterpolation(
+// 			options,
+// 			ctx,
+// 			code.slice(1, -1),
+// 			astHolder,
+// 			offset + 1,
+// 			features,
+// 			'',
+// 			''
+// 		);
+// 	}
+// 	else {
+// 		yield* generateStringLiteralKey(code, offset, features)
+// 	}
+// 	yield `]`;
+// }
+//# sourceMappingURL=objectKey.js.map

package/lib/languageModule.js

@@ -1,14 +1,15 @@
 "use strict";
+/// <reference types="@volar/typescript" />
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVueLanguagePlugin = createVueLanguagePlugin;
 const language_core_1 = require("@volar/language-core");
-const plugins_1 = require("./plugins");
-const vueFile_1 = require("./virtualFile/vueFile");
 const CompilerDOM = require("@vue/compiler-dom");
-const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+const plugins_1 = require("./plugins");
 const file_html_1 = require("./plugins/file-html");
 const file_md_1 = require("./plugins/file-md");
 const file_vue_1 = require("./plugins/file-vue");
+const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+const vueFile_1 = require("./virtualFile/vueFile");
 const normalFileRegistries = [];
 const holderFileRegistries = [];
 function getVueFileRegistry(isGlobalTypesHolder, key, plugins) {

package/lib/languagePlugin.d.ts

@@ -0,0 +1,8 @@
+import { type LanguagePlugin } from '@volar/language-core';
+import type * as ts from 'typescript';
+import type { VueCompilerOptions } from './types';
+import { VueVirtualCode } from './virtualFile/vueFile';
+export declare function createRootFileChecker(getProjectVersion: (() => string) | undefined, getRootFileNames: () => string[], caseSensitive: boolean): (fileName: string) => boolean;
+export declare function createVueLanguagePlugin<T>(ts: typeof import('typescript'), asFileName: (scriptId: T) => string, _getProjectVersion: (() => string) | undefined, isRootFile: (fileName: string) => boolean, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): LanguagePlugin<T, VueVirtualCode>;
+export declare function createVueLanguagePlugin2<T>(ts: typeof import('typescript'), asFileName: (scriptId: T) => string, isRootFile: (fileName: string) => boolean, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): LanguagePlugin<T, VueVirtualCode>;
+export declare function getAllExtensions(options: VueCompilerOptions): string[];

package/lib/languagePlugin.js

@@ -0,0 +1,175 @@
+"use strict";
+/// <reference types="@volar/typescript" />
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRootFileChecker = createRootFileChecker;
+exports.createVueLanguagePlugin = createVueLanguagePlugin;
+exports.createVueLanguagePlugin2 = createVueLanguagePlugin2;
+exports.getAllExtensions = getAllExtensions;
+const language_core_1 = require("@volar/language-core");
+const CompilerDOM = require("@vue/compiler-dom");
+const plugins_1 = require("./plugins");
+const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+const vueFile_1 = require("./virtualFile/vueFile");
+const normalFileRegistries = [];
+const holderFileRegistries = [];
+function getVueFileRegistry(isGlobalTypesHolder, key, plugins) {
+    const fileRegistries = isGlobalTypesHolder ? holderFileRegistries : normalFileRegistries;
+    let fileRegistry = fileRegistries.find(r => r.key === key
+        && r.plugins.length === plugins.length
+        && r.plugins.every(plugin => plugins.includes(plugin)))?.files;
+    if (!fileRegistry) {
+        fileRegistry = new Map();
+        fileRegistries.push({
+            key: key,
+            plugins: plugins,
+            files: fileRegistry,
+        });
+    }
+    return fileRegistry;
+}
+function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
+    const values = [
+        ...Object.keys(vueCompilerOptions)
+            .sort()
+            .filter(key => key !== 'plugins')
+            .map(key => [key, vueCompilerOptions[key]]),
+        [...new Set(plugins.map(plugin => plugin.requiredCompilerOptions ?? []).flat())]
+            .sort()
+            .map(key => [key, compilerOptions[key]]),
+    ];
+    return JSON.stringify(values);
+}
+function createRootFileChecker(getProjectVersion, getRootFileNames, caseSensitive) {
+    const fileNames = new language_core_1.FileMap(caseSensitive);
+    let projectVersion;
+    return (fileName) => {
+        if (!getProjectVersion || projectVersion !== getProjectVersion()) {
+            projectVersion = getProjectVersion?.();
+            fileNames.clear();
+            for (const rootFileName of getRootFileNames()) {
+                fileNames.set(rootFileName, undefined);
+            }
+        }
+        return fileNames.has(fileName);
+    };
+}
+// TODO: replace `createVueLanguagePlugin` with `createVueLanguagePlugin2` in 2.1
+function createVueLanguagePlugin(ts, asFileName, _getProjectVersion, isRootFile, compilerOptions, vueCompilerOptions) {
+    return createVueLanguagePlugin2(ts, asFileName, isRootFile, compilerOptions, vueCompilerOptions);
+}
+function createVueLanguagePlugin2(ts, asFileName, isRootFile, compilerOptions, vueCompilerOptions) {
+    const pluginContext = {
+        modules: {
+            '@vue/compiler-dom': vueCompilerOptions.target < 3
+                ? {
+                    ...CompilerDOM,
+                    compile: CompilerVue2.compile,
+                }
+                : CompilerDOM,
+            typescript: ts,
+        },
+        compilerOptions,
+        vueCompilerOptions,
+        globalTypesHolder: undefined,
+    };
+    const plugins = (0, plugins_1.createPlugins)(pluginContext);
+    return {
+        getLanguageId(scriptId) {
+            const fileName = asFileName(scriptId);
+            for (const plugin of plugins) {
+                const languageId = plugin.getLanguageId?.(fileName);
+                if (languageId) {
+                    return languageId;
+                }
+            }
+        },
+        createVirtualCode(scriptId, languageId, snapshot) {
+            const fileName = asFileName(scriptId);
+            if (plugins.some(plugin => plugin.isValidFile?.(fileName, languageId))) {
+                if (!pluginContext.globalTypesHolder && isRootFile(fileName)) {
+                    pluginContext.globalTypesHolder = fileName;
+                }
+                const fileRegistry = getFileRegistry(pluginContext.globalTypesHolder === fileName);
+                const code = fileRegistry.get(fileName);
+                if (code) {
+                    code.update(snapshot);
+                    return code;
+                }
+                else {
+                    const code = new vueFile_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
+                    fileRegistry.set(fileName, code);
+                    return code;
+                }
+            }
+        },
+        updateVirtualCode(_fileId, code, snapshot) {
+            code.update(snapshot);
+            return code;
+        },
+        // TODO: when global types holder deleted, move global types to another file
+        // disposeVirtualCode(fileId, code) {
+        // 	const isGlobalTypesHolder = code.fileName === pluginContext.globalTypesHolder;
+        // 	const fileRegistry = getFileRegistry(isGlobalTypesHolder);
+        // 	fileRegistry.delete(fileId);
+        // 	if (isGlobalTypesHolder) {
+        // 		pluginContext.globalTypesHolder = undefined;
+        // 		const fileRegistry2 = getFileRegistry(false);
+        // 		for (const [fileId, code] of fileRegistry2) {
+        // 			if (isValidGlobalTypesHolder(code.fileName)) {
+        // 				pluginContext.globalTypesHolder = code.fileName;
+        // 				fileRegistry2.delete(fileId);
+        // 				// force dirty
+        // 				files?.delete(fileId);
+        // 				files?.set(
+        // 					fileId,
+        // 					code.languageId,
+        // 					code.snapshot,
+        // 				);
+        // 				break;
+        // 			}
+        // 		}
+        // 	}
+        // },
+        typescript: {
+            extraFileExtensions: getAllExtensions(vueCompilerOptions)
+                .map(ext => ({
+                extension: ext.slice(1),
+                isMixedContent: true,
+                scriptKind: 7,
+            })),
+            getServiceScript(root) {
+                for (const code of (0, language_core_1.forEachEmbeddedCode)(root)) {
+                    if (/script_(js|jsx|ts|tsx)/.test(code.id)) {
+                        const lang = code.id.substring('script_'.length);
+                        return {
+                            code,
+                            extension: '.' + lang,
+                            scriptKind: lang === 'js' ? ts.ScriptKind.JS
+                                : lang === 'jsx' ? ts.ScriptKind.JSX
+                                    : lang === 'tsx' ? ts.ScriptKind.TSX
+                                        : ts.ScriptKind.TS,
+                        };
+                    }
+                }
+            },
+        },
+    };
+    function getFileRegistry(isGlobalTypesHolder) {
+        return getVueFileRegistry(isGlobalTypesHolder, getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins), vueCompilerOptions.plugins);
+    }
+}
+function getAllExtensions(options) {
+    const result = new Set();
+    for (const key in options) {
+        if (key === 'extensions' || key.endsWith('Extensions')) {
+            const value = options[key];
+            if (Array.isArray(value) && value.every(v => typeof v === 'string')) {
+                for (const ext of value) {
+                    result.add(ext);
+                }
+            }
+        }
+    }
+    return [...result];
+}
+//# sourceMappingURL=languagePlugin.js.map

package/lib/plugins/file-dot-setup.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/file-dot-setup.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSfc_1 = require("../utils/parseSfc");
+const jsxWrapper = ['<script setup lang="jsx">\n', '\n</script>'];
+const tsxWrapper = ['<script setup lang="tsx">\n', '\n</script>'];
+const plugin = _ctx => {
+    return {
+        version: 2.1,
+        isValidFile(fileName) {
+            return fileName.endsWith('.setup.jsx') || fileName.endsWith('.setup.tsx');
+        },
+        parseSFC2(fileName, _languageId, content) {
+            if (fileName.endsWith('.setup.jsx')) {
+                console.log('[Vue] parseSFC2', fileName);
+                return patchSFC((0, parseSfc_1.parse)(`${jsxWrapper[0]}${content}${jsxWrapper[1]}`));
+            }
+            if (fileName.endsWith('.setup.tsx')) {
+                console.log('[Vue] parseSFC2', fileName);
+                return patchSFC((0, parseSfc_1.parse)(`${tsxWrapper[0]}${content}${tsxWrapper[1]}`));
+            }
+        },
+    };
+};
+exports.default = plugin;
+function patchSFC(sfc) {
+    sfc.descriptor.scriptSetup.loc.start.column -= jsxWrapper[0].length;
+    sfc.descriptor.scriptSetup.loc.start.offset -= jsxWrapper[0].length;
+    sfc.descriptor.scriptSetup.loc.end.offset -= jsxWrapper[0].length;
+    if (sfc.descriptor.scriptSetup.loc.end.line === sfc.descriptor.scriptSetup.loc.start.line) {
+        sfc.descriptor.scriptSetup.loc.end.column -= jsxWrapper[0].length;
+    }
+    return sfc;
+}
+//# sourceMappingURL=file-dot-setup.js.map

package/lib/plugins/file-html.js

@@ -2,10 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const sfcBlockReg = /\<(script|style)\b([\s\S]*?)\>([\s\S]*?)\<\/\1\>/g;
 const langReg = /\blang\s*=\s*(['\"]?)(\S*)\b\1/;
-const plugin = () => {
+const plugin = ({ vueCompilerOptions }) => {
     return {
-        version: 2,
-        parseSFC(fileName, content) {
+        version: 2.1,
+        getLanguageId(fileName) {
+            if (vueCompilerOptions.petiteVueExtensions.some(ext => fileName.endsWith(ext))) {
+                return 'html';
+            }
+        },
+        isValidFile(_fileName, languageId) {
+            return languageId === 'html';
+        },
+        parseSFC2(fileName, languageId, content) {
+            if (languageId !== 'html') {
+                return;
+            }
             let sfc = {
                 descriptor: {
                     filename: fileName,

package/lib/plugins/file-md.js

@@ -11,10 +11,21 @@ const sfcBlockReg = /\<(script|style)\b[\s\S]*?\>([\s\S]*?)\<\/\1\>/g;
 const angleBracketReg = /\<\S*\:\S*\>/g;
 const linkReg = /\[[\s\S]*?\]\([\s\S]*?\)/g;
 const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
-const plugin = () => {
+const plugin = ({ vueCompilerOptions }) => {
     return {
-        version: 2,
-        parseSFC(_fileName, content) {
+        version: 2.1,
+        getLanguageId(fileName) {
+            if (vueCompilerOptions.vitePressExtensions.some(ext => fileName.endsWith(ext))) {
+                return 'markdown';
+            }
+        },
+        isValidFile(_fileName, languageId) {
+            return languageId === 'markdown';
+        },
+        parseSFC2(_fileName, languageId, content) {
+            if (languageId !== 'markdown') {
+                return;
+            }
             content = content
                 // code block
                 .replace(codeblockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)

package/lib/plugins/file-vue.js

@@ -1,10 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const parseSfc_1 = require("../utils/parseSfc");
-const plugin = _ctx => {
+const plugin = ({ vueCompilerOptions }) => {
     return {
-        version: 2,
-        parseSFC(_fileName, content) {
+        version: 2.1,
+        getLanguageId(fileName) {
+            if (vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext))) {
+                return 'vue';
+            }
+        },
+        isValidFile(_fileName, languageId) {
+            return languageId === 'vue';
+        },
+        parseSFC2(_fileName, languageId, content) {
+            if (languageId !== 'vue') {
+                return;
+            }
             return (0, parseSfc_1.parse)(content);
         },
         updateSFC(sfc, change) {

package/lib/plugins/vue-script-js.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = ({ modules }) => {
     return {
-        version: 2,
+        version: 2.1,
         compileSFCScript(lang, script) {
             if (lang === 'js' || lang === 'ts' || lang === 'jsx' || lang === 'tsx') {
                 const ts = modules.typescript;

package/lib/plugins/vue-sfc-customblocks.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const plugin = () => {
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             return sfc.customBlocks.map((customBlock, i) => ({
                 id: 'custom_block_' + i,

package/lib/plugins/vue-sfc-scripts.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = () => {
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             const names = [];
             if (sfc.script) {

package/lib/plugins/vue-sfc-styles.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const plugin = () => {
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             const result = [];
             for (let i = 0; i < sfc.styles.length; i++) {

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const shared_1 = require("./shared");
 const plugin = () => {
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             if (sfc.template) {
                 return [{

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = ({ modules }) => {
     return {
-        version: 2,
+        version: 2.1,
         compileSFCTemplate(lang, template, options) {
             if (lang === 'html' || lang === 'md') {
                 const compiler = modules['@vue/compiler-dom'];

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

@@ -10,7 +10,7 @@ const codeFeatures = {
 };
 const plugin = () => {
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             if (!sfc.template?.ast) {
                 return [];

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

@@ -22,7 +22,7 @@ const formatBrackets = {
 const plugin = ctx => {
     const parseds = new WeakMap();
     return {
-        version: 2,
+        version: 2.1,
         getEmbeddedCodes(_fileName, sfc) {
             if (!sfc.template?.ast) {
                 return [];

package/lib/plugins/vue-tsx.js

@@ -10,7 +10,7 @@ const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
 exports.tsCodegen = new WeakMap();
 const plugin = ctx => {
     return {
-        version: 2,
+        version: 2.1,
         requiredCompilerOptions: [
             'noPropertyAccessFromIndexSignature',
             'exactOptionalPropertyTypes',

package/lib/plugins.d.ts

@@ -1,27 +1,3 @@
-import { pluginVersion, type VueLanguagePlugin } from './types';
+import { VueLanguagePlugin } from './types';
 export * from './plugins/shared';
-export declare function getBasePlugins(pluginContext: Parameters<VueLanguagePlugin>[0]): {
-    version: typeof pluginVersion;
-    name?: string;
-    order?: number;
-    requiredCompilerOptions?: string[];
-    parseSFC?(fileName: string, content: string): import("@vue/compiler-sfc").SFCParseResult | undefined;
-    updateSFC?(oldResult: import("@vue/compiler-sfc").SFCParseResult, textChange: {
-        start: number;
-        end: number;
-        newText: string;
-    }): import("@vue/compiler-sfc").SFCParseResult | undefined;
-    resolveTemplateCompilerOptions?(options: import("@vue/compiler-dom").CompilerOptions): import("@vue/compiler-dom").CompilerOptions;
-    compileSFCScript?(lang: string, script: string): import("typescript").SourceFile | undefined;
-    compileSFCTemplate?(lang: string, template: string, options: import("@vue/compiler-dom").CompilerOptions): import("@vue/compiler-dom").CodegenResult | undefined;
-    updateSFCTemplate?(oldResult: import("@vue/compiler-dom").CodegenResult, textChange: {
-        start: number;
-        end: number;
-        newText: string;
-    }): import("@vue/compiler-dom").CodegenResult | undefined;
-    getEmbeddedCodes?(fileName: string, sfc: import("./types").Sfc): {
-        id: string;
-        lang: string;
-    }[];
-    resolveEmbeddedCode?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./types").VueEmbeddedCode): void;
-}[];
+export declare function createPlugins(pluginContext: Parameters<VueLanguagePlugin>[0]): import("./types").VueLanguagePluginReturn[];

package/lib/plugins.js

@@ -14,20 +14,26 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBasePlugins = getBasePlugins;
+exports.createPlugins = createPlugins;
+const file_html_1 = require("./plugins/file-html");
+const file_md_1 = require("./plugins/file-md");
+const file_vue_1 = require("./plugins/file-vue");
+const vue_script_js_1 = require("./plugins/vue-script-js");
 const vue_sfc_customblocks_1 = require("./plugins/vue-sfc-customblocks");
 const vue_sfc_scripts_1 = require("./plugins/vue-sfc-scripts");
 const vue_sfc_styles_1 = require("./plugins/vue-sfc-styles");
 const vue_sfc_template_1 = require("./plugins/vue-sfc-template");
-const vue_script_js_1 = require("./plugins/vue-script-js");
 const vue_template_html_1 = require("./plugins/vue-template-html");
 const vue_template_inline_css_1 = require("./plugins/vue-template-inline-css");
 const vue_template_inline_ts_1 = require("./plugins/vue-template-inline-ts");
 const vue_tsx_1 = require("./plugins/vue-tsx");
 const types_1 = require("./types");
 __exportStar(require("./plugins/shared"), exports);
-function getBasePlugins(pluginContext) {
+function createPlugins(pluginContext) {
     const plugins = [
+        file_vue_1.default,
+        file_md_1.default,
+        file_html_1.default,
         vue_script_js_1.default,
         vue_template_html_1.default,
         vue_template_inline_css_1.default,
@@ -40,28 +46,36 @@ function getBasePlugins(pluginContext) {
         ...pluginContext.vueCompilerOptions.plugins,
     ];
     const pluginInstances = plugins
-        .map(plugin => {
+        .flatMap(plugin => {
         try {
             const instance = plugin(pluginContext);
-            instance.name ??= plugin.__moduleName;
+            const moduleName = plugin.__moduleName;
+            if (Array.isArray(instance)) {
+                for (let i = 0; i < instance.length; i++) {
+                    instance[i].name ??= `${moduleName} (${i})`;
+                }
+            }
+            else {
+                instance.name ??= moduleName;
+            }
             return instance;
         }
         catch (err) {
             console.warn('[Vue] Failed to create plugin', err);
         }
     })
-        .filter((plugin) => !!plugin)
+        .filter(plugin => !!plugin)
         .sort((a, b) => {
         const aOrder = a.order ?? 0;
         const bOrder = b.order ?? 0;
         return aOrder - bOrder;
     });
     return pluginInstances.filter(plugin => {
-        const valid = plugin.version === types_1.pluginVersion;
-        if (!valid) {
-            console.warn(`[Vue] Plugin ${JSON.stringify(plugin.name)} API version incompatible, expected "${types_1.pluginVersion}" but got "${plugin.version}".`);
+        if (!types_1.validVersions.includes(plugin.version)) {
+            console.warn(`[Vue] Plugin ${plugin.name} is not compatible with the current Vue language tools version. (version: ${plugin.version}, supported versions: ${JSON.stringify(types_1.validVersions)})`);
+            return false;
         }
-        return valid;
+        return true;
     });
 }
 //# sourceMappingURL=plugins.js.map

package/lib/types.d.ts

@@ -48,21 +48,16 @@ export interface VueCompilerOptions {
     experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
     experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
 }
-export declare const pluginVersion = 2;
-export type VueLanguagePlugin = (ctx: {
-    modules: {
-        typescript: typeof import('typescript');
-        '@vue/compiler-dom': typeof import('@vue/compiler-dom');
-    };
-    compilerOptions: ts.CompilerOptions;
-    vueCompilerOptions: VueCompilerOptions;
-    globalTypesHolder: string | undefined;
-}) => {
-    version: typeof pluginVersion;
+export declare const validVersions: readonly [2, 2.1];
+export type VueLanguagePluginReturn = {
+    version: typeof validVersions[number];
     name?: string;
     order?: number;
     requiredCompilerOptions?: string[];
+    getLanguageId?(fileName: string): string | undefined;
+    isValidFile?(fileName: string, languageId: string): boolean;
     parseSFC?(fileName: string, content: string): SFCParseResult | undefined;
+    parseSFC2?(fileName: string, languageId: string, content: string): SFCParseResult | undefined;
     updateSFC?(oldResult: SFCParseResult, textChange: {
         start: number;
         end: number;
@@ -82,6 +77,15 @@ export type VueLanguagePlugin = (ctx: {
     }[];
     resolveEmbeddedCode?(fileName: string, sfc: Sfc, embeddedFile: VueEmbeddedCode): void;
 };
+export type VueLanguagePlugin = (ctx: {
+    modules: {
+        typescript: typeof import('typescript');
+        '@vue/compiler-dom': typeof import('@vue/compiler-dom');
+    };
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    globalTypesHolder: string | undefined;
+}) => VueLanguagePluginReturn | VueLanguagePluginReturn[];
 export interface SfcBlock {
     name: string;
     start: number;

package/lib/types.js

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

package/lib/utils/ts.js

@@ -4,6 +4,7 @@ exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
 exports.createParsedCommandLine = createParsedCommandLine;
 exports.resolveVueCompilerOptions = resolveVueCompilerOptions;
 const path = require("path-browserify");
+const languagePlugin_1 = require("../languagePlugin");
 function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json') {
     const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
     ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName);
@@ -18,11 +19,8 @@ function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, confi
         catch (err) { }
     }
     const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
-    const parsed = ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName, undefined, [
-        ...resolvedVueOptions.extensions,
-        ...resolvedVueOptions.vitePressExtensions,
-        ...resolvedVueOptions.petiteVueExtensions,
-    ].map(extension => ({
+    const parsed = ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName, undefined, (0, languagePlugin_1.getAllExtensions)(resolvedVueOptions)
+        .map(extension => ({
         extension: extension.slice(1),
         isMixedContent: true,
         scriptKind: ts.ScriptKind.Deferred,
@@ -52,11 +50,8 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath) {
             catch (err) { }
         }
         const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
-        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath, undefined, [
-            ...resolvedVueOptions.extensions,
-            ...resolvedVueOptions.vitePressExtensions,
-            ...resolvedVueOptions.petiteVueExtensions,
-        ].map(extension => ({
+        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath, undefined, (0, languagePlugin_1.getAllExtensions)(resolvedVueOptions)
+            .map(extension => ({
             extension: extension.slice(1),
             isMixedContent: true,
             scriptKind: ts.ScriptKind.Deferred,
@@ -129,14 +124,7 @@ function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
                 const resolvedPath = resolvePath(pluginPath);
                 if (resolvedPath) {
                     const plugin = require(resolvedPath);
-                    if (Array.isArray(plugin)) {
-                        for (let i = 0; i < plugin.length; i++) {
-                            plugin[i].__moduleName = `${pluginPath} (${i})`;
-                        }
-                    }
-                    else {
-                        plugin.__moduleName = pluginPath;
-                    }
+                    plugin.__moduleName = pluginPath;
                     return plugin;
                 }
                 else {
@@ -147,8 +135,7 @@ function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
                 console.warn('[Vue] Resolve plugin path failed:', pluginPath, error);
             }
             return [];
-        })
-            .flat(Infinity);
+        });
         result.plugins = plugins;
     }
     return result;

package/lib/virtualFile/computedFiles.d.ts

@@ -1,4 +1,4 @@
 import type { VirtualCode } from '@volar/language-core';
-import type { Sfc, VueLanguagePlugin } from '../types';
-export declare function computedFiles(plugins: ReturnType<VueLanguagePlugin>[], fileName: string, sfc: Sfc): () => VirtualCode[];
+import type { Sfc, VueLanguagePluginReturn } from '../types';
+export declare function computedFiles(plugins: VueLanguagePluginReturn[], fileName: string, sfc: Sfc): () => VirtualCode[];
 export declare function resolveCommonLanguageId(lang: string): string;

package/lib/virtualFile/computedSfc.d.ts

@@ -1,4 +1,4 @@
 import type { SFCParseResult } from '@vue/compiler-sfc';
 import type * as ts from 'typescript';
-import type { Sfc, VueLanguagePlugin } from '../types';
-export declare function computedSfc(ts: typeof import('typescript'), plugins: ReturnType<VueLanguagePlugin>[], fileName: string, snapshot: () => ts.IScriptSnapshot, parsed: () => SFCParseResult | undefined): Sfc;
+import type { Sfc, VueLanguagePluginReturn } from '../types';
+export declare function computedSfc(ts: typeof import('typescript'), plugins: VueLanguagePluginReturn[], fileName: string, snapshot: () => ts.IScriptSnapshot, parsed: () => SFCParseResult | undefined): Sfc;

package/lib/virtualFile/computedVueSfc.d.ts

@@ -1,4 +1,4 @@
 import type { SFCParseResult } from '@vue/compiler-sfc';
 import type * as ts from 'typescript';
-import type { VueLanguagePlugin } from '../types';
-export declare function computedVueSfc(plugins: ReturnType<VueLanguagePlugin>[], fileName: string, snapshot: () => ts.IScriptSnapshot): () => SFCParseResult | undefined;
+import type { VueLanguagePluginReturn } from '../types';
+export declare function computedVueSfc(plugins: VueLanguagePluginReturn[], fileName: string, languageId: string, snapshot: () => ts.IScriptSnapshot): () => SFCParseResult | undefined;

package/lib/virtualFile/computedVueSfc.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computedVueSfc = computedVueSfc;
 const computeds_1 = require("computeds");
-function computedVueSfc(plugins, fileName, snapshot) {
+function computedVueSfc(plugins, fileName, languageId, snapshot) {
     let cache;
     return (0, computeds_1.computed)(() => {
         // incremental update
@@ -23,7 +23,8 @@ function computedVueSfc(plugins, fileName, snapshot) {
             }
         }
         for (const plugin of plugins) {
-            const sfc = plugin.parseSFC?.(fileName, snapshot().getText(0, snapshot().getLength()));
+            const sfc = plugin.parseSFC?.(fileName, snapshot().getText(0, snapshot().getLength()))
+                ?? plugin.parseSFC2?.(fileName, languageId, snapshot().getText(0, snapshot().getLength()));
             if (sfc) {
                 if (!sfc.errors.length) {
                     cache = {

package/lib/virtualFile/vueFile.d.ts

@@ -1,13 +1,13 @@
 import type { VirtualCode } from '@volar/language-core';
 import { Signal } from 'computeds';
 import type * as ts from 'typescript';
-import type { VueCompilerOptions, VueLanguagePlugin } from '../types';
+import type { VueCompilerOptions, VueLanguagePluginReturn } from '../types';
 export declare class VueVirtualCode implements VirtualCode {
     fileName: string;
     languageId: string;
     initSnapshot: ts.IScriptSnapshot;
     vueCompilerOptions: VueCompilerOptions;
-    plugins: ReturnType<VueLanguagePlugin>[];
+    plugins: VueLanguagePluginReturn[];
     ts: typeof import('typescript');
     id: string;
     _snapshot: Signal<ts.IScriptSnapshot>;
@@ -18,6 +18,6 @@ export declare class VueVirtualCode implements VirtualCode {
     get embeddedCodes(): VirtualCode[];
     get snapshot(): ts.IScriptSnapshot;
     get mappings(): import("@volar/language-core").CodeMapping[];
-    constructor(fileName: string, languageId: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: ReturnType<VueLanguagePlugin>[], ts: typeof import('typescript'));
+    constructor(fileName: string, languageId: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: VueLanguagePluginReturn[], ts: typeof import('typescript'));
     update(newSnapshot: ts.IScriptSnapshot): void;
 }

package/lib/virtualFile/vueFile.js

@@ -27,7 +27,7 @@ class VueVirtualCode {
         // sources
         this.id = 'main';
         // computeds
-        this.getVueSfc = (0, computedVueSfc_1.computedVueSfc)(this.plugins, this.fileName, () => this._snapshot());
+        this.getVueSfc = (0, computedVueSfc_1.computedVueSfc)(this.plugins, this.fileName, this.languageId, () => this._snapshot());
         this.sfc = (0, computedSfc_1.computedSfc)(this.ts, this.plugins, this.fileName, () => this._snapshot(), this.getVueSfc);
         this.getMappings = (0, computedMappings_1.computedMappings)(() => this._snapshot(), this.sfc);
         this.getEmbeddedCodes = (0, computedFiles_1.computedFiles)(this.plugins, this.fileName, this.sfc);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "2.0.26",
+	"version": "2.0.28",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "~2.4.0-alpha.15",
+		"@volar/language-core": "~2.4.0-alpha.18",
 		"@vue/compiler-dom": "^3.4.0",
 		"@vue/shared": "^3.4.0",
 		"computeds": "^0.0.1",
@@ -25,7 +25,7 @@
 		"@types/minimatch": "^5.1.2",
 		"@types/node": "latest",
 		"@types/path-browserify": "^1.0.1",
-		"@volar/typescript": "~2.4.0-alpha.15",
+		"@volar/typescript": "~2.4.0-alpha.18",
 		"@vue/compiler-sfc": "^3.4.0"
 	},
 	"peerDependencies": {
@@ -36,5 +36,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "47924f61e9409501d11ab04e9d3417cc5c86232c"
+	"gitHead": "0cdbd70996f4fc7ac8d511b0d9fdbe20b7a4f6a3"
 }