@vue/language-core 3.1.0 → 3.1.2

package/lib/codegen/script/component.js

@@ -5,10 +5,11 @@ const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const merge_1 = require("../utils/merge");
 function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
-    if (options.sfc.script && options.scriptRanges?.exportDefault
-        && options.scriptRanges.exportDefault.expression.start !== options.scriptRanges.exportDefault.args.start) {
+    if (options.sfc.script
+        && options.scriptRanges?.componentOptions
+        && options.scriptRanges.componentOptions.expression.start !== options.scriptRanges.componentOptions.args.start) {
         // use defineComponent() from user space code if it exist
-        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, options.scriptRanges.exportDefault.expression.start, options.scriptRanges.exportDefault.args.start, codeFeatures_1.codeFeatures.all);
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, options.scriptRanges.componentOptions.expression.start, options.scriptRanges.componentOptions.args.start, codeFeatures_1.codeFeatures.all);
         yield `{${utils_1.newLine}`;
     }
     else {
@@ -50,8 +51,8 @@ function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
         && options.templateCodegen?.singleRootElTypes.length) {
         yield `__typeEl: {} as __VLS_RootEl,${utils_1.newLine}`;
     }
-    if (options.sfc.script && options.scriptRanges?.exportDefault?.args) {
-        const { args } = options.scriptRanges.exportDefault;
+    if (options.sfc.script && options.scriptRanges?.componentOptions?.args) {
+        const { args } = options.scriptRanges.componentOptions;
         yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, codeFeatures_1.codeFeatures.all);
     }
     yield `})`;
@@ -90,7 +91,7 @@ function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasE
     if (options.templateCodegen?.inheritedAttrVars.size) {
         let attrsType = `__VLS_InheritedAttrs`;
         if (hasEmitsOption) {
-            attrsType = `Omit<${attrsType}, \`on\${string}\`>`;
+            attrsType = `Omit<${attrsType}, keyof __VLS_EmitProps>`;
         }
         getOptionCodes.push(() => {
             const propsType = `__VLS_PickNotAny<${ctx.localTypes.OmitIndexSignature}<${attrsType}>, {}>`;

package/lib/codegen/script/index.js

@@ -24,7 +24,7 @@ function* generateScript(options, ctx) {
         yield* (0, scriptSetup_1.generateScriptSetupImports)(options.sfc.scriptSetup, options.scriptSetupRanges);
     }
     if (options.sfc.script && options.scriptRanges) {
-        const { exportDefault } = options.scriptRanges;
+        const { exportDefault, componentOptions } = options.scriptRanges;
         if (options.sfc.scriptSetup && options.scriptSetupRanges) {
             if (exportDefault) {
                 yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, 0, exportDefault.start, codeFeatures_1.codeFeatures.all);
@@ -36,14 +36,15 @@ function* generateScript(options, ctx) {
             }
         }
         else if (exportDefault) {
+            const { expression } = componentOptions ?? exportDefault;
             let wrapLeft;
             let wrapRight;
-            if (options.sfc.script.content[exportDefault.expression.start] === '{'
+            if (options.sfc.script.content[expression.start] === '{'
                 && options.vueCompilerOptions.optionsWrapper.length) {
                 [wrapLeft, wrapRight] = options.vueCompilerOptions.optionsWrapper;
                 ctx.inlayHints.push({
                     blockName: options.sfc.script.name,
-                    offset: exportDefault.expression.start,
+                    offset: expression.start,
                     setting: 'vue.inlayHints.optionsWrapper',
                     label: wrapLeft || '[Missing optionsWrapper[0]]',
                     tooltip: [
@@ -52,7 +53,7 @@ function* generateScript(options, ctx) {
                     ].join('\n\n'),
                 }, {
                     blockName: options.sfc.script.name,
-                    offset: exportDefault.expression.end,
+                    offset: expression.end,
                     setting: 'vue.inlayHints.optionsWrapper',
                     label: wrapRight || '[Missing optionsWrapper[1]]',
                 });
@@ -62,7 +63,7 @@ function* generateScript(options, ctx) {
             if (wrapLeft) {
                 yield wrapLeft;
             }
-            yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.start, exportDefault.expression.end, codeFeatures_1.codeFeatures.all);
+            yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, expression.start, expression.end, codeFeatures_1.codeFeatures.all);
             if (wrapRight) {
                 yield wrapRight;
             }
@@ -103,12 +104,10 @@ function* generateGlobalTypesReference(options) {
 }
 function* generateConstExport(options, block) {
     if (options.sfc.script) {
-        yield* (0, utils_1.generatePartiallyEnding)(options.sfc.script.name, options.scriptRanges?.exportDefault
-            ? options.scriptRanges.exportDefault.start
-            : options.sfc.script.content.length, '#3632/script.vue');
+        yield* (0, utils_1.generatePartiallyEnding)(options.sfc.script.name, options.scriptRanges?.exportDefault?.start ?? options.sfc.script.content.length, '#3632/script.vue');
     }
     yield `const `;
-    yield* (0, wrapWith_1.wrapWith)(0, block.content.length, block.name, codeFeatures_1.codeFeatures.verification, `__VLS_export`);
+    yield* (0, wrapWith_1.wrapWith)(0, block.content.length, block.name, codeFeatures_1.codeFeatures.doNotReportTs6133, `__VLS_export`);
     yield ` = `;
 }
 function* generateExportDefault(options) {
@@ -119,9 +118,9 @@ function* generateExportDefault(options) {
     let prefix;
     let suffix;
     if (options.sfc.script && options.scriptRanges?.exportDefault) {
-        const { exportDefault } = options.scriptRanges;
-        prefix = (0, utils_1.generateSfcBlockSection)(options.sfc.script, exportDefault.start, exportDefault.expression.start, codeFeatures_1.codeFeatures.all);
-        suffix = (0, utils_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.end, options.sfc.script.content.length, codeFeatures_1.codeFeatures.all);
+        const { exportDefault, componentOptions } = options.scriptRanges;
+        prefix = (0, utils_1.generateSfcBlockSection)(options.sfc.script, exportDefault.start, (componentOptions ?? exportDefault).expression.start, codeFeatures_1.codeFeatures.all);
+        suffix = (0, utils_1.generateSfcBlockSection)(options.sfc.script, (componentOptions ?? exportDefault).expression.end, options.sfc.script.content.length, codeFeatures_1.codeFeatures.all);
     }
     else {
         prefix = `export default `;

package/lib/codegen/script/scriptSetup.js

@@ -65,7 +65,7 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
             emitTypes.push(`typeof __VLS_modelEmit`);
         }
         yield `return {} as {${utils_1.newLine}`
-            + `	props: ${ctx.localTypes.PrettifyLocal}<${propTypes.join(` & `)}> & ${options.vueCompilerOptions.target >= 3.4
+            + `	props: ${propTypes.length ? `${ctx.localTypes.PrettifyLocal}<${propTypes.join(` & `)}> & ` : ``}${options.vueCompilerOptions.target >= 3.4
                 ? `import('${options.vueCompilerOptions.lib}').PublicProps`
                 : options.vueCompilerOptions.target >= 3
                     ? `import('${options.vueCompilerOptions.lib}').VNodeProps`

package/lib/codegen/script/template.js

@@ -21,12 +21,18 @@ function* generateTemplate(options, ctx) {
     yield* generateTemplateBody(options, ctx);
 }
 function* generateSelf(options) {
-    if (options.sfc.script && options.scriptRanges?.exportDefault) {
+    if (options.sfc.script && options.scriptRanges?.componentOptions) {
         yield `const __VLS_self = (await import('${options.vueCompilerOptions.lib}')).defineComponent(`;
-        const { args } = options.scriptRanges.exportDefault;
+        const { args } = options.scriptRanges.componentOptions;
         yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, args.start, args.end, codeFeatures_1.codeFeatures.all);
         yield `)${utils_1.endOfLine}`;
     }
+    else if (options.sfc.script && options.scriptRanges?.exportDefault) {
+        yield `const __VLS_self = `;
+        const { expression } = options.scriptRanges.exportDefault;
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, expression.start, expression.end, codeFeatures_1.codeFeatures.all);
+        yield utils_1.endOfLine;
+    }
     else if (options.sfc.script?.src) {
         yield `let __VLS_self!: typeof import('./${path.basename(options.fileName)}').default${utils_1.endOfLine}`;
     }
@@ -92,10 +98,10 @@ function* generateTemplateElements() {
 }
 function* generateTemplateComponents(options) {
     const types = [`typeof __VLS_ctx`];
-    if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {
-        const { componentsOption } = options.scriptRanges.exportDefault;
+    if (options.sfc.script && options.scriptRanges?.componentOptions?.components) {
+        const { components } = options.scriptRanges.componentOptions;
         yield `const __VLS_componentsOption = `;
-        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, componentsOption.start, componentsOption.end, codeFeatures_1.codeFeatures.navigation);
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, components.start, components.end, codeFeatures_1.codeFeatures.navigation);
         yield utils_1.endOfLine;
         types.push(`typeof __VLS_componentsOption`);
     }
@@ -104,10 +110,10 @@ function* generateTemplateComponents(options) {
 }
 function* generateTemplateDirectives(options) {
     const types = [`typeof __VLS_ctx`];
-    if (options.sfc.script && options.scriptRanges?.exportDefault?.directivesOption) {
-        const { directivesOption } = options.scriptRanges.exportDefault;
+    if (options.sfc.script && options.scriptRanges?.componentOptions?.directives) {
+        const { directives } = options.scriptRanges.componentOptions;
         yield `const __VLS_directivesOption = `;
-        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, directivesOption.start, directivesOption.end, codeFeatures_1.codeFeatures.navigation);
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, directives.start, directives.end, codeFeatures_1.codeFeatures.navigation);
         yield utils_1.endOfLine;
         types.push(`__VLS_ResolveDirectives<typeof __VLS_directivesOption>`);
     }

package/lib/codegen/template/element.js

@@ -146,11 +146,11 @@ function* generateComponent(options, ctx, node) {
     yield* generateFailedPropExps(options, ctx, failedPropExps);
     yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, componentOriginalVar, componentFunctionalVar, componentVNodeVar, componentCtxVar);
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
-    const [refName, offset] = yield* generateElementReference(options, ctx, node);
+    const reference = yield* generateElementReference(options, ctx, node);
     const tag = (0, shared_2.hyphenateTag)(node.tag);
     const isRootNode = ctx.singleRootNodes.has(node)
         && !options.vueCompilerOptions.fallthroughComponentNames.includes(tag);
-    if (refName || isRootNode) {
+    if (reference || isRootNode) {
         const componentInstanceVar = ctx.getInternalVariable();
         ctx.currentComponent.used = true;
         yield `var ${componentInstanceVar} = {} as (Parameters<NonNullable<typeof ${componentCtxVar}['expose']>>[0] | null)`;
@@ -158,8 +158,9 @@ function* generateComponent(options, ctx, node) {
             yield `[]`;
         }
         yield utils_1.endOfLine;
-        if (refName && offset) {
-            ctx.addTemplateRef(refName, `typeof ${ctx.getHoistVariable(componentInstanceVar)}`, offset);
+        if (reference) {
+            const typeExp = `typeof ${ctx.getHoistVariable(componentInstanceVar)}`;
+            ctx.addTemplateRef(reference.name, typeExp, reference.offset);
         }
         if (isRootNode) {
             ctx.singleRootElTypes.push(`NonNullable<typeof ${componentInstanceVar}>['$el']`);
@@ -167,7 +168,8 @@ function* generateComponent(options, ctx, node) {
     }
     if (hasVBindAttrs(options, ctx, node)) {
         const attrsVar = ctx.getInternalVariable();
-        yield `var ${attrsVar}!: Parameters<typeof ${componentFunctionalVar}>[0]${utils_1.endOfLine}`;
+        ctx.currentComponent.used = true;
+        yield `var ${attrsVar}!: NonNullable<typeof ${componentCtxVar}['props']>${utils_1.endOfLine}`;
         ctx.inheritedAttrVars.add(attrsVar);
     }
     (0, styleScopedClasses_1.collectStyleScopedClassReferences)(options, ctx, node);
@@ -191,13 +193,13 @@ function* generateElement(options, ctx, node) {
     yield `)${utils_1.endOfLine}`;
     yield* generateFailedPropExps(options, ctx, failedPropExps);
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
-    const [refName, offset] = yield* generateElementReference(options, ctx, node);
-    if (refName && offset) {
+    const reference = yield* generateElementReference(options, ctx, node);
+    if (reference) {
         let typeExp = `__VLS_NativeElements['${node.tag}']`;
         if (ctx.inVFor) {
             typeExp += `[]`;
         }
-        ctx.addTemplateRef(refName, typeExp, offset);
+        ctx.addTemplateRef(reference.name, typeExp, reference.offset);
     }
     if (ctx.singleRootNodes.has(node)) {
         ctx.singleRootElTypes.push(`__VLS_NativeElements['${node.tag}']`);
@@ -259,18 +261,17 @@ function* generateElementReference(options, ctx, node) {
         if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
             && prop.name === 'ref'
             && prop.value) {
-            const [content, startOffset] = (0, utils_1.normalizeAttributeValue)(prop.value);
+            const [name, offset] = (0, utils_1.normalizeAttributeValue)(prop.value);
             // navigation support for `const foo = ref()`
             yield `/** @type {typeof __VLS_ctx`;
-            yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, content, startOffset, codeFeatures_1.codeFeatures.navigation);
+            yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, name, offset, codeFeatures_1.codeFeatures.navigation);
             yield `} */${utils_1.endOfLine}`;
-            if (utils_1.identifierRegex.test(content) && !options.templateRefNames.has(content)) {
-                ctx.accessExternalVariable(content, startOffset);
+            if (utils_1.identifierRegex.test(name) && !options.templateRefNames.has(name)) {
+                ctx.accessExternalVariable(name, offset);
             }
-            return [content, startOffset];
+            return { name, offset };
         }
     }
-    return [];
 }
 function hasVBindAttrs(options, ctx, node) {
     return options.vueCompilerOptions.fallthroughAttributes && ((options.inheritAttrs && ctx.singleRootNodes.has(node))

package/lib/codegen/template/templateChild.js

@@ -102,6 +102,8 @@ function* generateTemplateChild(options, ctx, node, enterNode = true) {
     }
 }
 function* collectSingleRootNodes(options, children) {
+    // Exclude the effect of comments on the root node
+    children = children.filter(node => node.type !== CompilerDOM.NodeTypes.COMMENT);
     if (children.length !== 1) {
         // "null" is used to determine whether the component is not always has a single root
         if (children.length > 1) {

package/lib/codegen/utils/index.d.ts

@@ -5,7 +5,7 @@ export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
 export declare const identifierRegex: RegExp;
-export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): [string, number];
+export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): readonly [string, number];
 export declare function createTsAst(ts: typeof import('typescript'), inlineTsAsts: Map<string, ts.SourceFile> | undefined, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;
 export declare function generatePartiallyEnding(source: string, end: number, mark: string, delimiter?: string): Generator<Code>;

package/lib/compilerOptions.d.ts

@@ -19,5 +19,9 @@ export declare class CompilerOptionsResolver {
     private findNodeModulesRoot;
 }
 export declare function getDefaultCompilerOptions(target?: number, lib?: string, strictTemplates?: boolean): VueCompilerOptions;
+export declare function createGlobalTypesWriter(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): (fileName: string) => string | void;
+/**
+ * @deprecated use `createGlobalTypesWriter` instead
+ */
 export declare function writeGlobalTypes(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): void;
 export {};

package/lib/compilerOptions.js

@@ -4,6 +4,7 @@ exports.CompilerOptionsResolver = void 0;
 exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
 exports.createParsedCommandLine = createParsedCommandLine;
 exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
+exports.createGlobalTypesWriter = createGlobalTypesWriter;
 exports.writeGlobalTypes = writeGlobalTypes;
 const shared_1 = require("@vue/shared");
 const path_browserify_1 = require("path-browserify");
@@ -274,10 +275,10 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         },
     };
 }
-function writeGlobalTypes(vueOptions, writeFile) {
+function createGlobalTypesWriter(vueOptions, writeFile) {
     const writed = new Set();
     const { globalTypesPath } = vueOptions;
-    vueOptions.globalTypesPath = (fileName) => {
+    return (fileName) => {
         const result = globalTypesPath(fileName);
         if (result && !writed.has(result)) {
             writed.add(result);
@@ -286,4 +287,10 @@ function writeGlobalTypes(vueOptions, writeFile) {
         return result;
     };
 }
+/**
+ * @deprecated use `createGlobalTypesWriter` instead
+ */
+function writeGlobalTypes(vueOptions, writeFile) {
+    vueOptions.globalTypesPath = createGlobalTypesWriter(vueOptions, writeFile);
+}
 //# sourceMappingURL=compilerOptions.js.map

package/lib/parsers/scriptRanges.d.ts

@@ -5,14 +5,17 @@ export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
 export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, hasScriptSetup: boolean): {
     exportDefault: (TextRange & {
         expression: TextRange;
+    }) | undefined;
+    componentOptions: {
+        expression: TextRange;
         args: TextRange;
         argsNode: ts.ObjectLiteralExpression;
-        componentsOption: TextRange | undefined;
-        componentsOptionNode: ts.ObjectLiteralExpression | undefined;
-        directivesOption: TextRange | undefined;
-        nameOption: TextRange | undefined;
-        inheritAttrsOption: string | undefined;
-    }) | undefined;
+        components: TextRange | undefined;
+        componentsNode: ts.ObjectLiteralExpression | undefined;
+        directives: TextRange | undefined;
+        name: TextRange | undefined;
+        inheritAttrs: string | undefined;
+    } | undefined;
     bindings: {
         range: TextRange;
         moduleName?: string;

package/lib/parsers/scriptRanges.js

@@ -5,9 +5,18 @@ const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
 function parseScriptRanges(ts, ast, hasScriptSetup) {
     let exportDefault;
+    let componentOptions;
     const bindings = hasScriptSetup ? (0, utils_1.parseBindingRanges)(ts, ast) : [];
     ts.forEachChild(ast, raw => {
         if (ts.isExportAssignment(raw)) {
+            exportDefault = {
+                ..._getStartEnd(raw),
+                expression: _getStartEnd(raw.expression),
+            };
+            const comment = (0, utils_1.getClosestMultiLineCommentRange)(ts, raw, [], ast);
+            if (comment) {
+                exportDefault.start = comment.start;
+            }
             let node = raw;
             while (isAsExpression(node.expression) || ts.isParenthesizedExpression(node.expression)) { // fix https://github.com/vuejs/language-tools/issues/1882
                 node = node.expression;
@@ -44,26 +53,22 @@ function parseScriptRanges(ts, ast, hasScriptSetup) {
                         }
                     }
                 });
-                exportDefault = {
-                    ..._getStartEnd(raw),
+                componentOptions = {
                     expression: _getStartEnd(node.expression),
                     args: _getStartEnd(obj),
                     argsNode: obj,
-                    componentsOption: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
-                    componentsOptionNode,
-                    directivesOption: directivesOptionNode ? _getStartEnd(directivesOptionNode) : undefined,
-                    nameOption: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
-                    inheritAttrsOption,
+                    components: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
+                    componentsNode: componentsOptionNode,
+                    directives: directivesOptionNode ? _getStartEnd(directivesOptionNode) : undefined,
+                    name: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
+                    inheritAttrs: inheritAttrsOption,
                 };
-                const comment = (0, utils_1.getClosestMultiLineCommentRange)(ts, raw, [], ast);
-                if (comment) {
-                    exportDefault.start = comment.start;
-                }
             }
         }
     });
     return {
         exportDefault,
+        componentOptions,
         bindings,
     };
     function _getStartEnd(node) {

package/lib/plugins/file-md.js

@@ -9,10 +9,10 @@ const codeblockReg = /(`{3,})[\s\S]+?\1/g;
 const inlineCodeblockReg = /`[^\n`]+?`/g;
 const latexBlockReg = /(\${2,})[\s\S]+?\1/g;
 const scriptSetupReg = /\\<[\s\S]+?>\n?/g;
+const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
+const sfcBlockReg = /<(script|style)\b[\s\S]*?>([\s\S]*?)<\/\1>/g;
 const angleBracketReg = /<\S*:\S*>/g;
 const linkReg = /\[[\s\S]*?\]\([\s\S]*?\)/g;
-const sfcBlockReg = /<(script|style)\b[\s\S]*?>([\s\S]*?)<\/\1>/g;
-const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
 const plugin = ({ vueCompilerOptions }) => {
     return {
         version: 2.2,
@@ -40,11 +40,7 @@ const plugin = ({ vueCompilerOptions }) => {
                 // # \<script setup>
                 .replace(scriptSetupReg, match => ' '.repeat(match.length))
                 // <<< https://vitepress.dev/guide/markdown#import-code-snippets
-                .replace(codeSnippetImportReg, match => ' '.repeat(match.length))
-                // angle bracket: <http://foo.com>
-                .replace(angleBracketReg, match => ' '.repeat(match.length))
-                // [foo](http://foo.com)
-                .replace(linkReg, match => ' '.repeat(match.length));
+                .replace(codeSnippetImportReg, match => ' '.repeat(match.length));
             const codes = [];
             for (const match of content.matchAll(sfcBlockReg)) {
                 const matchText = match[0];
@@ -53,6 +49,11 @@ const plugin = ({ vueCompilerOptions }) => {
                 content = content.slice(0, match.index) + ' '.repeat(matchText.length)
                     + content.slice(match.index + matchText.length);
             }
+            content = content
+                // angle bracket: <http://foo.com>
+                .replace(angleBracketReg, match => ' '.repeat(match.length))
+                // [foo](http://foo.com)
+                .replace(linkReg, match => ' '.repeat(match.length));
             codes.push('<template>\n');
             codes.push([content, undefined, 0]);
             codes.push('\n</template>');

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

@@ -4,14 +4,17 @@ export declare const tsCodegen: WeakMap<Sfc, {
     getScriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
+        }) | undefined;
+        componentOptions: {
+            expression: import("../types").TextRange;
             args: import("../types").TextRange;
             argsNode: import("typescript").ObjectLiteralExpression;
-            componentsOption: import("../types").TextRange | undefined;
-            componentsOptionNode: import("typescript").ObjectLiteralExpression | undefined;
-            directivesOption: import("../types").TextRange | undefined;
-            nameOption: import("../types").TextRange | undefined;
-            inheritAttrsOption: string | undefined;
-        }) | undefined;
+            components: import("../types").TextRange | undefined;
+            componentsNode: import("typescript").ObjectLiteralExpression | undefined;
+            directives: import("../types").TextRange | undefined;
+            name: import("../types").TextRange | undefined;
+            inheritAttrs: string | undefined;
+        } | undefined;
         bindings: {
             range: import("../types").TextRange;
             moduleName?: string;

package/lib/plugins/vue-tsx.js

@@ -122,14 +122,14 @@ function createTsx(fileName, sfc, ctx) {
     const getSetupSlotsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineSlots?.name);
     const getSetupInheritAttrs = (0, alien_signals_1.computed)(() => {
         const value = getScriptSetupRanges()?.defineOptions?.inheritAttrs
-            ?? getScriptRanges()?.exportDefault?.inheritAttrsOption;
+            ?? getScriptRanges()?.componentOptions?.inheritAttrs;
         return value !== 'false';
     });
     const getComponentSelfName = (0, alien_signals_1.computed)(() => {
         let name;
-        const { exportDefault } = getScriptRanges() ?? {};
-        if (sfc.script && exportDefault?.nameOption) {
-            name = sfc.script.content.slice(exportDefault.nameOption.start + 1, exportDefault.nameOption.end - 1);
+        const { componentOptions } = getScriptRanges() ?? {};
+        if (sfc.script && componentOptions?.name) {
+            name = sfc.script.content.slice(componentOptions.name.start + 1, componentOptions.name.end - 1);
         }
         else {
             const { defineOptions } = getScriptSetupRanges() ?? {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.1.0",
+	"version": "3.1.2",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -36,5 +36,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "fa32cb67b68c4fd01a146c7e2a276ffa022df268"
+	"gitHead": "77db3d889305e8c02740f4c14793bff0156ccdb8"
 }