@vue/language-core 3.2.8 → 3.3.0

package/lib/codegen/template/templateChild.js

@@ -45,14 +45,10 @@ const slotOutlet_1 = require("./slotOutlet");
 const vFor_1 = require("./vFor");
 const vIf_1 = require("./vIf");
 const vSlot_1 = require("./vSlot");
-function* generateTemplateChild(options, ctx, node, enterNode = true) {
+function* generateTemplateChild(options, ctx, node, enterNode = true, treatTemplateAsFragment = false) {
     if (enterNode && !ctx.enter(node)) {
         return;
     }
-    const cur = node;
-    if (cur.codegenNode?.type === CompilerDOM.NodeTypes.JS_CACHE_EXPRESSION) {
-        cur.codegenNode = cur.codegenNode.value;
-    }
     if (node.type === CompilerDOM.NodeTypes.ROOT) {
         for (const item of collectSingleRootNodes(options, node.children)) {
             ctx.singleRootNodes.add(item);
@@ -62,27 +58,25 @@ function* generateTemplateChild(options, ctx, node, enterNode = true) {
         }
     }
     else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
-        let slotDir;
         if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
             yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node);
         }
-        else if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE
-            && ctx.components.length
-            && (slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot'))) {
-            yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir, ctx.components[ctx.components.length - 1]());
-        }
-        else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
-            || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
-            yield* (0, element_1.generateElement)(options, ctx, node);
-        }
         else {
-            yield* (0, element_1.generateComponent)(options, ctx, node);
+            const slotDir = node.props.find(CompilerDOM.isVSlot);
+            if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE && ctx.components.length && slotDir) {
+                yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir, ctx.components.at(-1)());
+            }
+            else if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE && treatTemplateAsFragment) {
+                yield* (0, element_1.generateFragment)(options, ctx, node);
+            }
+            else if (node.tagType === CompilerDOM.ElementTypes.COMPONENT) {
+                yield* (0, element_1.generateComponent)(options, ctx, node);
+            }
+            else {
+                yield* (0, element_1.generateElement)(options, ctx, node);
+            }
         }
     }
-    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
-        // {{ var }}
-        yield* generateTemplateChild(options, ctx, node.content, false);
-    }
     else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
         // {{ ... }} {{ ... }}
         for (const child of node.children) {
@@ -105,14 +99,11 @@ function* generateTemplateChild(options, ctx, node, enterNode = true) {
         // v-for
         yield* (0, vFor_1.generateVFor)(options, ctx, node);
     }
-    else if (node.type === CompilerDOM.NodeTypes.TEXT) {
-        // not needed progress
-    }
     if (enterNode) {
         yield* ctx.exit();
     }
 }
-function* collectSingleRootNodes(options, children) {
+function* collectSingleRootNodes(options, children, treatTemplateAsFragment = false) {
     // Exclude the effect of comments on the root node
     children = children.filter(node => node.type !== CompilerDOM.NodeTypes.COMMENT);
     if (children.length !== 1) {
@@ -125,13 +116,17 @@ function* collectSingleRootNodes(options, children) {
     const child = children[0];
     if (child.type === CompilerDOM.NodeTypes.IF) {
         for (const branch of child.branches) {
-            yield* collectSingleRootNodes(options, branch.children);
+            yield* collectSingleRootNodes(options, branch.children, true);
         }
         return;
     }
     else if (child.type !== CompilerDOM.NodeTypes.ELEMENT) {
         return;
     }
+    if (child.tagType === CompilerDOM.ElementTypes.TEMPLATE && treatTemplateAsFragment) {
+        yield* collectSingleRootNodes(options, child.children);
+        return;
+    }
     yield child;
     const tag = (0, shared_1.hyphenateTag)(child.tag);
     if (options.vueCompilerOptions.fallthroughComponentNames.includes(tag)) {

package/lib/codegen/template/vFor.js

@@ -67,28 +67,10 @@ function* generateVFor(options, ctx, node) {
         yield `{} as any`;
     }
     yield `) {${utils_1.newLine}`;
-    let isFragment = true;
-    for (const argument of node.codegenNode?.children.arguments ?? []) {
-        if (argument.type === CompilerDOM.NodeTypes.JS_FUNCTION_EXPRESSION
-            && argument.returns?.type === CompilerDOM.NodeTypes.VNODE_CALL
-            && argument.returns.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION) {
-            if (argument.returns.tag !== CompilerDOM.FRAGMENT) {
-                isFragment = false;
-                continue;
-            }
-            for (const prop of argument.returns.props.properties) {
-                if (prop.value.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                    && !prop.value.isStatic) {
-                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, `(`, `)`);
-                    yield utils_1.endOfLine;
-                }
-            }
-        }
-    }
     const { inVFor } = ctx;
     ctx.inVFor = true;
     for (const child of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child, isFragment);
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child, false, true);
     }
     ctx.inVFor = inVFor;
     yield* endScope();

package/lib/codegen/template/vIf.js

@@ -42,10 +42,6 @@ const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
 function* generateVIf(options, ctx, node) {
     const originalBlockConditionsLength = ctx.blockConditions.length;
-    const isFragment = node.codegenNode
-        && 'consequent' in node.codegenNode
-        && 'tag' in node.codegenNode.consequent
-        && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
     for (let i = 0; i < node.branches.length; i++) {
         const branch = node.branches[i];
         if (i === 0) {
@@ -67,7 +63,7 @@ function* generateVIf(options, ctx, node) {
         }
         yield `{${utils_1.newLine}`;
         for (const child of branch.children) {
-            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child, i !== 0 || isFragment);
+            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child, i !== 0, true);
         }
         yield `}${utils_1.newLine}`;
         if (addedBlockCondition) {

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

@@ -1,8 +1,8 @@
 import type * as ts from 'typescript';
-import type { Code, Sfc, SfcBlock, VueCodeInformation } from '../../types';
+import type { Code, IRBlock, IRScript, IRScriptSetup, VueCodeInformation } from '../../types';
 export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const identifierRegex: RegExp;
-export declare function getTypeScriptAST(ts: typeof import('typescript'), block: SfcBlock, text: string): ts.SourceFile;
-export declare function generateSfcBlockSection(block: NonNullable<Sfc['script' | 'scriptSetup']>, start: number, end: number, features: VueCodeInformation): Generator<Code>;
+export declare function getTypeScriptAST(ts: typeof import('typescript'), block: IRBlock, text: string): ts.SourceFile;
+export declare function generateSfcBlockSection(block: IRScript | IRScriptSetup, start: number, end: number, features: VueCodeInformation): Generator<Code>;
 export declare function forEachNode(ts: typeof import('typescript'), node: ts.Node): Generator<ts.Node>;

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

@@ -1,3 +1,3 @@
 import type { Code } from '../../types';
-export declare function generateIntersectMerge(generates: Iterable<Code>[]): Generator<Code>;
-export declare function generateSpreadMerge(generates: Iterable<Code>[]): Generator<Code>;
+export declare function generateIntersectMerge(...codes: Code[]): Generator<Code>;
+export declare function generateSpreadMerge(...codes: Code[]): Generator<Code>;

package/lib/codegen/utils/merge.js

@@ -3,22 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateIntersectMerge = generateIntersectMerge;
 exports.generateSpreadMerge = generateSpreadMerge;
 const index_1 = require("./index");
-function* generateIntersectMerge(generates) {
-    yield* generates[0];
-    for (let i = 1; i < generates.length; i++) {
+function* generateIntersectMerge(...codes) {
+    yield codes[0];
+    for (let i = 1; i < codes.length; i++) {
         yield ` & `;
-        yield* generates[i];
+        yield codes[i];
     }
 }
-function* generateSpreadMerge(generates) {
-    if (generates.length === 1) {
-        yield* generates[0];
+function* generateSpreadMerge(...codes) {
+    if (codes.length <= 1) {
+        yield* codes;
     }
     else {
         yield `{${index_1.newLine}`;
-        for (const generate of generates) {
+        for (const code of codes) {
             yield `...`;
-            yield* generate;
+            yield code;
             yield `,${index_1.newLine}`;
         }
         yield `}`;

package/lib/compilerOptions.js

@@ -211,6 +211,7 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         inferTemplateDollarSlots: false,
         skipTemplateCodegen: false,
         fallthroughAttributes: false,
+        checkRequiredFallthroughAttributes: false,
         resolveStyleImports: false,
         resolveStyleClassNames: 'scoped',
         fallthroughComponentNames: [

package/lib/languagePlugin.js

@@ -38,6 +38,7 @@ exports.createVueLanguagePlugin = createVueLanguagePlugin;
 exports.getAllExtensions = getAllExtensions;
 const language_core_1 = require("@volar/language-core");
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
+const LanguageCore = __importStar(require("../index"));
 const plugins_1 = require("./plugins");
 const virtualCode_1 = require("./virtualCode");
 const fileRegistries = {};
@@ -60,6 +61,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
     const pluginContext = {
         modules: {
             '@vue/compiler-dom': CompilerDOM,
+            '@vue/language-core': LanguageCore,
             typescript: ts,
         },
         compilerOptions,

package/lib/plugins/file-md.js

@@ -5,14 +5,13 @@ const muggle_string_1 = require("muggle-string");
 const buildMappings_1 = require("../utils/buildMappings");
 const parseSfc_1 = require("../utils/parseSfc");
 const frontmatterReg = /^---[\s\S]*?\n---(?:\r?\n|$)/;
-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 codeblockReg = /(`{3}|\${2})[\s\S]+?\1/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]*?)<\/\1>/g;
+const htmlTagReg = /(?<=<\/?)([a-z][a-z0-9-]*)\b[^>]*(?=>)/gi;
+const interpolationReg = /(?<=\{\{)[\s\S]*?(?=\}\})/g;
+const inlineCodeReg = /(`{1,2})[^`]+\1/g;
+const angleBracketReg = /<[^\s:]*:\S*>/g;
 const plugin = ({ vueCompilerOptions }) => {
     return {
         version: 2.2,
@@ -28,32 +27,29 @@ const plugin = ({ vueCompilerOptions }) => {
             if (languageId !== 'markdown') {
                 return;
             }
-            content = content
-                // frontmatter
-                .replace(frontmatterReg, match => ' '.repeat(match.length))
-                // code block
-                .replace(codeblockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)
-                // latex block
-                .replace(latexBlockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)
-                // # \<script setup>
-                .replace(scriptSetupReg, match => ' '.repeat(match.length))
-                // <<< https://vitepress.dev/guide/markdown#import-code-snippets
-                .replace(codeSnippetImportReg, match => ' '.repeat(match.length));
+            for (const reg of [frontmatterReg, codeblockReg, codeSnippetImportReg]) {
+                content = content.replace(reg, match => ' '.repeat(match.length));
+            }
             const codes = [];
-            for (const match of content.matchAll(sfcBlockReg)) {
-                const matchText = match[0];
-                codes.push([matchText, undefined, match.index]);
+            for (const { 0: text, index } of content.matchAll(sfcBlockReg)) {
+                codes.push([text, undefined, index]);
                 codes.push('\n\n');
-                content = content.slice(0, match.index) + ' '.repeat(matchText.length)
-                    + content.slice(match.index + matchText.length);
+                content = content.slice(0, index) + ' '.repeat(text.length) + content.slice(index + text.length);
+            }
+            const ranges = [];
+            for (const reg of [htmlTagReg, interpolationReg]) {
+                for (const { 0: text, index } of content.matchAll(reg)) {
+                    ranges.push([index, index + text.length]);
+                }
+            }
+            for (const reg of [inlineCodeReg, angleBracketReg]) {
+                for (const { 0: text, index } of content.matchAll(reg)) {
+                    if (ranges.some(([start, end]) => index >= start && index < end)) {
+                        continue;
+                    }
+                    content = content.slice(0, index) + ' '.repeat(text.length) + content.slice(index + text.length);
+                }
             }
-            content = content
-                // inline code block
-                .replace(inlineCodeblockReg, match => `\`${' '.repeat(match.length - 2)}\``)
-                // 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-root-tags.js

@@ -11,27 +11,27 @@ const plugin = () => {
                     lang: 'vue-root-tags',
                 }];
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
             if (embeddedFile.id === 'root_tags') {
-                embeddedFile.content.push([sfc.content, undefined, 0, shared_1.allCodeFeatures]);
+                embeddedFile.content.push([ir.content, undefined, 0, shared_1.allCodeFeatures]);
                 for (const block of [
-                    sfc.template,
-                    sfc.script,
-                    sfc.scriptSetup,
-                    ...sfc.styles,
-                    ...sfc.customBlocks,
+                    ir.template,
+                    ir.script,
+                    ir.scriptSetup,
+                    ...ir.styles,
+                    ...ir.customBlocks,
                 ]) {
                     if (!block) {
                         continue;
                     }
                     const offset = block.content.lastIndexOf('\n', block.content.lastIndexOf('\n') - 1) + 1;
                     // fix folding range end position failed to mapping
-                    (0, muggle_string_1.replaceSourceRange)(embeddedFile.content, undefined, block.startTagEnd, block.endTagStart, sfc.content.slice(block.startTagEnd, block.startTagEnd + offset), [
+                    (0, muggle_string_1.replaceSourceRange)(embeddedFile.content, undefined, block.startTagEnd, block.endTagStart, ir.content.slice(block.startTagEnd, block.startTagEnd + offset), [
                         '',
                         undefined,
                         block.startTagEnd + offset,
                         { structure: true },
-                    ], sfc.content.slice(block.startTagEnd + offset, block.endTagStart));
+                    ], ir.content.slice(block.startTagEnd + offset, block.endTagStart));
                 }
             }
             else {

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

@@ -4,16 +4,16 @@ const shared_1 = require("./shared");
 const plugin = () => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
-            return sfc.customBlocks.map((customBlock, i) => ({
+        getEmbeddedCodes(_fileName, ir) {
+            return ir.customBlocks.map((customBlock, i) => ({
                 id: 'custom_block_' + i,
                 lang: customBlock.lang,
             }));
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
             if (embeddedFile.id.startsWith('custom_block_')) {
                 const index = parseInt(embeddedFile.id.slice('custom_block_'.length));
-                const customBlock = sfc.customBlocks[index];
+                const customBlock = ir.customBlocks[index];
                 embeddedFile.content.push([
                     customBlock.content,
                     customBlock.name,

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

@@ -3,21 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = () => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
+        getEmbeddedCodes(_fileName, ir) {
             const names = [];
-            if (sfc.script) {
-                names.push({ id: 'script_raw', lang: sfc.script.lang });
+            if (ir.script) {
+                names.push({ id: 'script_raw', lang: ir.script.lang });
             }
-            if (sfc.scriptSetup) {
-                names.push({ id: 'scriptsetup_raw', lang: sfc.scriptSetup.lang });
+            if (ir.scriptSetup) {
+                names.push({ id: 'scriptsetup_raw', lang: ir.scriptSetup.lang });
             }
             return names;
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
             const script = embeddedFile.id === 'script_raw'
-                ? sfc.script
+                ? ir.script
                 : embeddedFile.id === 'scriptsetup_raw'
-                    ? sfc.scriptSetup
+                    ? ir.scriptSetup
                     : undefined;
             if (script) {
                 embeddedFile.content.push([

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

@@ -4,10 +4,10 @@ const shared_1 = require("./shared");
 const plugin = () => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
+        getEmbeddedCodes(_fileName, ir) {
             const result = [];
-            for (let i = 0; i < sfc.styles.length; i++) {
-                const style = sfc.styles[i];
+            for (let i = 0; i < ir.styles.length; i++) {
+                const style = ir.styles[i];
                 if (style) {
                     result.push({
                         id: 'style_' + i,
@@ -23,10 +23,10 @@ const plugin = () => {
             }
             return result;
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
             if (embeddedFile.id.startsWith('style_')) {
                 const index = parseInt(embeddedFile.id.split('_')[1]);
-                const style = sfc.styles[index];
+                const style = ir.styles[index];
                 if (embeddedFile.id.endsWith('_inline_ts')) {
                     embeddedFile.parentCodeId = 'style_' + index;
                     for (const binding of style.bindings) {

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

@@ -4,20 +4,20 @@ const shared_1 = require("./shared");
 const plugin = () => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
-            if (sfc.template?.lang === 'html') {
+        getEmbeddedCodes(_fileName, ir) {
+            if (ir.template?.lang === 'html') {
                 return [{
                         id: 'template',
-                        lang: sfc.template.lang,
+                        lang: ir.template.lang,
                     }];
             }
             return [];
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
-            if (embeddedFile.id === 'template' && sfc.template?.lang === 'html') {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
+            if (embeddedFile.id === 'template' && ir.template?.lang === 'html') {
                 embeddedFile.content.push([
-                    sfc.template.content,
-                    sfc.template.name,
+                    ir.template.content,
+                    ir.template.name,
                     0,
                     shared_1.allCodeFeatures,
                 ]);

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

@@ -1,8 +1,42 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+const CompilerDOM = __importStar(require("@vue/compiler-dom"));
+const compile_1 = require("../template/compile");
 const shouldAddSuffix = /(?<=<[^>/]+)$/;
-const plugin = ({ modules }) => {
-    const CompilerDOM = modules['@vue/compiler-dom'];
+const plugin = () => {
     return {
         version: 2.2,
         compileSFCTemplate(lang, template, options) {
@@ -13,11 +47,7 @@ const plugin = ({ modules }) => {
                     template += '>';
                     addedSuffix = true;
                 }
-                const ast = CompilerDOM.parse(template, {
-                    ...options,
-                    comments: true,
-                });
-                CompilerDOM.transform(ast, options);
+                const ast = (0, compile_1.compileTemplate)(template, options);
                 return {
                     ast,
                     code: '',
@@ -97,11 +127,6 @@ const plugin = ({ modules }) => {
                             return false;
                         }
                     }
-                    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
-                        if (!tryUpdateNode(node.content)) {
-                            return false;
-                        }
-                    }
                     else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
                         for (const childNode of node.children) {
                             if (typeof childNode === 'object') {

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

@@ -45,18 +45,18 @@ const codeFeatures = {
 const plugin = () => {
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
-            if (!sfc.template?.ast) {
+        getEmbeddedCodes(_fileName, ir) {
+            if (!ir.template?.ast) {
                 return [];
             }
             return [{ id: 'template_inline_css', lang: 'css' }];
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
-            if (embeddedFile.id !== 'template_inline_css' || !sfc.template?.ast) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
+            if (embeddedFile.id !== 'template_inline_css' || !ir.template?.ast) {
                 return;
             }
-            embeddedFile.parentCodeId = sfc.template.lang === 'md' ? 'root_tags' : 'template';
-            embeddedFile.content.push(...generate(sfc.template.ast));
+            embeddedFile.parentCodeId = ir.template.lang === 'md' ? 'root_tags' : 'template';
+            embeddedFile.content.push(...generate(ir.template.ast));
         },
     };
 };

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

@@ -57,42 +57,42 @@ const plugin = ({ modules: { typescript: ts } }) => {
     const parseds = new WeakMap();
     return {
         version: 2.2,
-        getEmbeddedCodes(_fileName, sfc) {
-            if (!sfc.template?.ast) {
+        getEmbeddedCodes(_fileName, ir) {
+            if (!ir.template?.ast) {
                 return [];
             }
-            const parsed = parse(sfc);
-            parseds.set(sfc, parsed);
+            const parsed = parse(ir);
+            parseds.set(ir, parsed);
             const result = [];
             for (const [id] of parsed) {
                 result.push({ id, lang: 'ts' });
             }
             return result;
         },
-        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+        resolveEmbeddedCode(_fileName, ir, embeddedFile) {
             if (!embeddedFile.id.startsWith('template_inline_ts_')) {
                 return;
             }
             // access template content to watch change
-            void sfc.template?.content;
-            const parsed = parseds.get(sfc);
+            void ir.template?.content;
+            const parsed = parseds.get(ir);
             if (parsed) {
                 const codes = parsed.get(embeddedFile.id);
                 if (codes) {
                     embeddedFile.content.push(...codes);
-                    embeddedFile.parentCodeId = sfc.template?.lang === 'md' ? 'root_tags' : 'template';
+                    embeddedFile.parentCodeId = ir.template?.lang === 'md' ? 'root_tags' : 'template';
                 }
             }
         },
     };
-    function parse(sfc) {
+    function parse(ir) {
         const result = new Map();
-        if (!sfc.template?.ast) {
+        if (!ir.template?.ast) {
             return result;
         }
-        const template = sfc.template;
+        const template = ir.template;
         let i = 0;
-        sfc.template.ast.children.forEach(visit);
+        ir.template.ast.children.forEach(visit);
         return result;
         function visit(node) {
             if (node.type === CompilerDOM.NodeTypes.COMMENT) {
@@ -178,10 +178,6 @@ const plugin = ({ modules: { typescript: ts } }) => {
                     visit(child);
                 }
             }
-            else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
-                // {{ var }}
-                visit(node.content);
-            }
             else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
                 // {{ ... }} {{ ... }}
                 for (const childNode of node.children) {

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

@@ -1,5 +1,5 @@
-import type { Sfc, VueLanguagePlugin } from '../types';
-export declare const tsCodegen: WeakMap<Sfc, {
+import type { IR, VueLanguagePlugin } from '../types';
+export declare const tsCodegen: WeakMap<IR, {
     getScriptRanges: () => {
         exportDefault: (import("../types").TextRange<import("typescript").Node> & {
             expression: import("../types").TextRange<import("typescript").Expression>;