@vue/language-core 3.1.5 → 3.1.7

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

@@ -1,3 +1,3 @@
 import type { Code } from '../../types';
-export declare function generateIntersectMerge(codes: Code[]): Generator<Code>;
-export declare function generateSpreadMerge(codes: Code[]): Generator<Code>;
+export declare function generateIntersectMerge(generates: Iterable<Code>[]): Generator<Code>;
+export declare function generateSpreadMerge(generates: Iterable<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(codes) {
-    yield codes[0];
-    for (let i = 1; i < codes.length; i++) {
+function* generateIntersectMerge(generates) {
+    yield* generates[0];
+    for (let i = 1; i < generates.length; i++) {
         yield ` & `;
-        yield codes[i];
+        yield* generates[i];
     }
 }
-function* generateSpreadMerge(codes) {
-    if (codes.length === 1) {
-        yield codes[0];
+function* generateSpreadMerge(generates) {
+    if (generates.length === 1) {
+        yield* generates[0];
     }
     else {
         yield `{${index_1.newLine}`;
-        for (const code of codes) {
+        for (const generate of generates) {
             yield `...`;
-            yield code;
+            yield* generate;
             yield `,${index_1.newLine}`;
         }
         yield `}`;

package/lib/codegen/utils/stringLiteralKey.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStringLiteralKey = generateStringLiteralKey;
-const index_1 = require("./index");
-const wrapWith_1 = require("./wrapWith");
+const boundary_1 = require("./boundary");
 function* generateStringLiteralKey(code, offset, info) {
     if (offset === undefined || !info) {
         yield `'${code}'`;
     }
     else {
-        yield* (0, wrapWith_1.wrapWith)('template', offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
+        const token = yield* (0, boundary_1.startBoundary)('template', offset, info);
+        yield `'`;
+        yield [code, 'template', offset, { __combineToken: token }];
+        yield `'`;
+        yield (0, boundary_1.endBoundary)(token, offset + code.length);
     }
 }
 //# sourceMappingURL=stringLiteralKey.js.map

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

@@ -0,0 +1,8 @@
+import type { Code } from '../../types';
+export interface CodeTransform {
+    range: [start: number, end: number];
+    generate(): Iterable<Code>;
+}
+export declare function replace(start: number, end: number, replacement: () => Iterable<Code>): CodeTransform;
+export declare function insert(position: number, insertion: () => Iterable<Code>): CodeTransform;
+export declare function generateCodeWithTransforms(start: number, end: number, transforms: CodeTransform[], section: (start: number, end: number) => Iterable<Code>): Generator<Code>;

package/lib/codegen/utils/transform.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replace = replace;
+exports.insert = insert;
+exports.generateCodeWithTransforms = generateCodeWithTransforms;
+function replace(start, end, replacement) {
+    return {
+        range: [start, end],
+        generate: replacement,
+    };
+}
+function insert(position, insertion) {
+    return {
+        range: [position, position],
+        generate: insertion,
+    };
+}
+function* generateCodeWithTransforms(start, end, transforms, section) {
+    const sortedTransforms = transforms.sort((a, b) => a.range[0] - b.range[0]);
+    for (const { range, generate } of sortedTransforms) {
+        yield* section(start, range[0]);
+        yield* generate();
+        start = range[1];
+    }
+    yield* section(start, end);
+}
+//# sourceMappingURL=transform.js.map

package/lib/codegen/utils/unicode.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateUnicode = generateUnicode;
-const wrapWith_1 = require("./wrapWith");
+const boundary_1 = require("./boundary");
 function* generateUnicode(code, offset, info) {
     if (needToUnicode(code)) {
-        yield* (0, wrapWith_1.wrapWith)('template', offset, offset + code.length, info, toUnicode(code));
+        const token = yield* (0, boundary_1.startBoundary)('template', offset, info);
+        yield toUnicode(code);
+        yield (0, boundary_1.endBoundary)(token, offset + code.length);
     }
     else {
         yield [code, 'template', offset, info];

package/lib/compilerOptions.d.ts

@@ -1,10 +1,12 @@
 import type * as ts from 'typescript';
 import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from './types';
+interface ParseConfigHost extends Omit<ts.ParseConfigHost, 'readDirectory'> {
+}
 export interface ParsedCommandLine extends Omit<ts.ParsedCommandLine, 'fileNames'> {
     vueOptions: VueCompilerOptions;
 }
-export declare const createParsedCommandLineByJson: (ts: typeof import("typescript"), host: Omit<ts.ParseConfigHost, "readDirectory">, rootDir: string, json: any, configFileName?: string | undefined) => ParsedCommandLine;
-export declare const createParsedCommandLine: (ts: typeof import("typescript"), host: Omit<ts.ParseConfigHost, "readDirectory">, configFileName: string) => ParsedCommandLine;
+export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), host: ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
+export declare function createParsedCommandLine(ts: typeof import('typescript'), host: ParseConfigHost, configFileName: string): ParsedCommandLine;
 export declare class CompilerOptionsResolver {
     fileExists?: ((path: string) => boolean) | undefined;
     options: Omit<RawVueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>;
@@ -22,3 +24,4 @@ export declare function createGlobalTypesWriter(vueOptions: VueCompilerOptions,
  * @deprecated use `createGlobalTypesWriter` instead
  */
 export declare function writeGlobalTypes(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): void;
+export {};

package/lib/compilerOptions.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompilerOptionsResolver = exports.createParsedCommandLine = exports.createParsedCommandLineByJson = void 0;
+exports.CompilerOptionsResolver = void 0;
+exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
+exports.createParsedCommandLine = createParsedCommandLine;
 exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
 exports.createGlobalTypesWriter = createGlobalTypesWriter;
 exports.writeGlobalTypes = writeGlobalTypes;
@@ -8,54 +10,75 @@ const shared_1 = require("@vue/shared");
 const path_browserify_1 = require("path-browserify");
 const globalTypes_1 = require("./codegen/globalTypes");
 const shared_2 = require("./utils/shared");
-exports.createParsedCommandLineByJson = create((ts, host, rootDir, json, configFileName) => {
-    // `parseJsonConfigFileContent` is missing in tsc
-    return 'parseJsonConfigFileContent' in ts
-        ? ts.parseJsonConfigFileContent(json, host, rootDir, {}, configFileName)
-        : ts.parseJsonSourceFileConfigFileContent(ts.parseJsonText(configFileName ?? 'tsconfig.json', JSON.stringify(json)), host, rootDir, {}, configFileName);
-});
-exports.createParsedCommandLine = create((ts, host, configFileName) => {
-    const config = ts.readJsonConfigFile(configFileName, host.readFile);
-    return ts.parseJsonSourceFileConfigFileContent(config, host, path_browserify_1.posix.dirname(configFileName), {}, configFileName);
-});
-function create(getParsedCommandLine) {
-    return (ts, host, ...args) => {
+function createParsedCommandLineByJson(ts, host, rootDir, json, configFileName) {
+    const extendedPaths = new Set();
+    const proxyHost = {
+        ...host,
+        readFile(fileName) {
+            if (!fileName.endsWith('/package.json')) {
+                extendedPaths.add(fileName);
+            }
+            return host.readFile(fileName);
+        },
+        readDirectory() {
+            return [];
+        },
+    };
+    const config = ts.readJsonConfigFile(rootDir, () => JSON.stringify(json));
+    const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost, rootDir, {}, configFileName);
+    const resolver = new CompilerOptionsResolver(host.fileExists);
+    for (const extendPath of [...extendedPaths].reverse()) {
         try {
-            const extendedPaths = new Set();
-            const proxyHost = {
-                ...host,
-                readFile(fileName) {
-                    if (!fileName.endsWith('/package.json')) {
-                        extendedPaths.add(fileName);
-                    }
-                    return host.readFile(fileName);
-                },
-                readDirectory() {
-                    return [];
-                },
-            };
-            const parsed = getParsedCommandLine(ts, proxyHost, ...args);
-            const resolver = new CompilerOptionsResolver(host.fileExists);
-            for (const extendPath of [...extendedPaths].reverse()) {
-                try {
-                    const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
-                    const obj = ts.convertToObject(configFile, []);
-                    const rawOptions = obj?.vueCompilerOptions ?? {};
-                    resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
+            const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
+            const obj = ts.convertToObject(configFile, []);
+            const rawOptions = obj?.vueCompilerOptions ?? {};
+            resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
+        }
+        catch { }
+    }
+    resolver.addConfig(json?.vueCompilerOptions ?? {}, rootDir);
+    return {
+        ...parsed,
+        vueOptions: resolver.build(),
+    };
+}
+function createParsedCommandLine(ts, host, configFileName) {
+    try {
+        const extendedPaths = new Set();
+        const proxyHost = {
+            ...host,
+            readFile(fileName) {
+                if (!fileName.endsWith('/package.json')) {
+                    extendedPaths.add(fileName);
                 }
-                catch { }
+                return host.readFile(fileName);
+            },
+            readDirectory() {
+                return [];
+            },
+        };
+        const config = ts.readJsonConfigFile(configFileName, proxyHost.readFile);
+        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost, path_browserify_1.posix.dirname(configFileName), {}, configFileName);
+        const resolver = new CompilerOptionsResolver(host.fileExists);
+        for (const extendPath of [...extendedPaths].reverse()) {
+            try {
+                const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
+                const obj = ts.convertToObject(configFile, []);
+                const rawOptions = obj?.vueCompilerOptions ?? {};
+                resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
             }
-            return {
-                ...parsed,
-                vueOptions: resolver.build(),
-            };
+            catch { }
         }
-        catch { }
         return {
-            options: {},
-            errors: [],
-            vueOptions: getDefaultCompilerOptions(),
+            ...parsed,
+            vueOptions: resolver.build(),
         };
+    }
+    catch { }
+    return {
+        options: {},
+        errors: [],
+        vueOptions: getDefaultCompilerOptions(),
     };
 }
 class CompilerOptionsResolver {
@@ -128,7 +151,7 @@ class CompilerOptionsResolver {
                 ...defaults.fallthroughComponentNames,
                 ...this.options.fallthroughComponentNames ?? [],
             ].map(shared_2.hyphenateTag),
-            // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
+            // https://github.com/vuejs/core/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
             // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
             experimentalModelPropName: Object.fromEntries(Object.entries(this.options.experimentalModelPropName ?? defaults.experimentalModelPropName).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
         };

package/lib/languagePlugin.d.ts

@@ -1,6 +1,6 @@
 import { type LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions } from './types';
-import { VueVirtualCode } from './virtualFile/vueFile';
+import { VueVirtualCode } from './virtualCode';
 export declare function createVueLanguagePlugin<T>(ts: typeof import('typescript'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, asFileName: (scriptId: T) => string): LanguagePlugin<T, VueVirtualCode>;
 export declare function getAllExtensions(options: VueCompilerOptions): string[];

package/lib/languagePlugin.js

@@ -6,7 +6,7 @@ exports.getAllExtensions = getAllExtensions;
 const language_core_1 = require("@volar/language-core");
 const CompilerDOM = require("@vue/compiler-dom");
 const plugins_1 = require("./plugins");
-const vueFile_1 = require("./virtualFile/vueFile");
+const virtualCode_1 = require("./virtualCode");
 const fileRegistries = {};
 function getVueFileRegistry(compilerOptions, vueCompilerOptions, plugins) {
     const key = JSON.stringify([
@@ -47,14 +47,14 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
         createVirtualCode(scriptId, languageId, snapshot) {
             const fileName = asFileName(scriptId);
             if (plugins.some(plugin => plugin.isValidFile?.(fileName, languageId))) {
-                const code = fileRegistry.get(fileName);
+                const code = fileRegistry.get(String(scriptId));
                 if (code) {
                     code.update(snapshot);
                     return code;
                 }
                 else {
-                    const code = new vueFile_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
-                    fileRegistry.set(fileName, code);
+                    const code = new virtualCode_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
+                    fileRegistry.set(String(scriptId), code);
                     return code;
                 }
             }
@@ -64,8 +64,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
             return code;
         },
         disposeVirtualCode(scriptId) {
-            const fileName = asFileName(scriptId);
-            fileRegistry.delete(fileName);
+            fileRegistry.delete(String(scriptId));
         },
         typescript: {
             extraFileExtensions: getAllExtensions(vueCompilerOptions)

package/lib/parsers/scriptRanges.d.ts

@@ -1,8 +1,8 @@
 import type * as ts from 'typescript';
-import type { TextRange } from '../types';
+import type { TextRange, VueCompilerOptions } from '../types';
 export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
 }
-export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, hasScriptSetup: boolean): {
+export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
     exportDefault: (TextRange & {
         expression: TextRange;
     }) | undefined;
@@ -16,10 +16,6 @@ export declare function parseScriptRanges(ts: typeof import('typescript'), ast:
         name: TextRange | undefined;
         inheritAttrs: string | undefined;
     } | undefined;
-    bindings: {
-        range: TextRange;
-        moduleName?: string;
-        isDefaultImport?: boolean;
-        isNamespace?: boolean;
-    }[];
+    bindings: TextRange[];
+    components: TextRange[];
 };

package/lib/parsers/scriptRanges.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptRanges = parseScriptRanges;
 const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
-function parseScriptRanges(ts, ast, hasScriptSetup) {
+function parseScriptRanges(ts, ast, vueCompilerOptions) {
     let exportDefault;
     let componentOptions;
-    const bindings = hasScriptSetup ? (0, utils_1.parseBindingRanges)(ts, ast) : [];
+    const { bindings, components } = (0, utils_1.parseBindingRanges)(ts, ast, vueCompilerOptions.extensions);
     ts.forEachChild(ast, raw => {
         if (ts.isExportAssignment(raw)) {
             exportDefault = {
@@ -70,6 +70,7 @@ function parseScriptRanges(ts, ast, hasScriptSetup) {
         exportDefault,
         componentOptions,
         bindings,
+        components,
     };
     function _getStartEnd(node) {
         return (0, shared_1.getStartEnd)(ts, node, ast);

package/lib/parsers/scriptSetupRanges.d.ts

@@ -48,12 +48,8 @@ export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRan
 export declare function parseScriptSetupRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
     leadingCommentEndOffset: number;
     importSectionEndOffset: number;
-    bindings: {
-        range: TextRange;
-        moduleName?: string;
-        isDefaultImport?: boolean;
-        isNamespace?: boolean;
-    }[];
+    bindings: TextRange[];
+    components: TextRange[];
     defineModel: DefineModel[];
     defineProps: DefineProps | undefined;
     withDefaults: WithDefaults | undefined;

package/lib/parsers/scriptSetupRanges.js

@@ -20,7 +20,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const text = ast.text;
     const leadingCommentRanges = ts.getLeadingCommentRanges(text, 0)?.reverse() ?? [];
     const leadingCommentEndOffset = leadingCommentRanges.find(range => tsCheckReg.test(text.slice(range.pos, range.end)))?.end ?? 0;
-    let bindings = (0, utils_1.parseBindingRanges)(ts, ast);
+    let { bindings, components } = (0, utils_1.parseBindingRanges)(ts, ast, vueCompilerOptions.extensions);
     let foundNonImportExportNode = false;
     let importSectionEndOffset = 0;
     ts.forEachChild(ast, node => {
@@ -48,7 +48,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     });
     ts.forEachChild(ast, node => visitNode(node, [ast]));
     const templateRefNames = new Set(useTemplateRef.map(ref => ref.name));
-    bindings = bindings.filter(({ range }) => {
+    bindings = bindings.filter(range => {
         const name = text.slice(range.start, range.end);
         return !templateRefNames.has(name);
     });
@@ -56,6 +56,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         leadingCommentEndOffset,
         importSectionEndOffset,
         bindings,
+        components,
         defineModel,
         defineProps,
         withDefaults,

package/lib/parsers/utils.d.ts

@@ -1,11 +1,9 @@
 import type * as ts from 'typescript';
 import type { TextRange } from '../types';
-export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile): {
-    range: TextRange;
-    moduleName?: string;
-    isDefaultImport?: boolean;
-    isNamespace?: boolean;
-}[];
+export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile, componentExtsensions: string[]): {
+    bindings: TextRange[];
+    components: TextRange[];
+};
 export declare function getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): {
     start: number;
     end: number;

package/lib/parsers/utils.js

@@ -4,44 +4,37 @@ exports.parseBindingRanges = parseBindingRanges;
 exports.getClosestMultiLineCommentRange = getClosestMultiLineCommentRange;
 const collectBindings_1 = require("../utils/collectBindings");
 const shared_1 = require("../utils/shared");
-function parseBindingRanges(ts, ast) {
+function parseBindingRanges(ts, ast, componentExtsensions) {
     const bindings = [];
+    const components = [];
     ts.forEachChild(ast, node => {
         if (ts.isVariableStatement(node)) {
             for (const decl of node.declarationList.declarations) {
                 const ranges = (0, collectBindings_1.collectBindingRanges)(ts, decl.name, ast);
-                bindings.push(...ranges.map(range => ({ range })));
+                bindings.push(...ranges);
             }
         }
         else if (ts.isFunctionDeclaration(node)) {
             if (node.name && ts.isIdentifier(node.name)) {
-                bindings.push({
-                    range: _getStartEnd(node.name),
-                });
+                bindings.push(_getStartEnd(node.name));
             }
         }
         else if (ts.isClassDeclaration(node)) {
             if (node.name) {
-                bindings.push({
-                    range: _getStartEnd(node.name),
-                });
+                bindings.push(_getStartEnd(node.name));
             }
         }
         else if (ts.isEnumDeclaration(node)) {
-            bindings.push({
-                range: _getStartEnd(node.name),
-            });
+            bindings.push(_getStartEnd(node.name));
         }
         if (ts.isImportDeclaration(node)) {
             const moduleName = _getNodeText(node.moduleSpecifier).slice(1, -1);
             if (node.importClause && !node.importClause.isTypeOnly) {
                 const { name, namedBindings } = node.importClause;
                 if (name) {
-                    bindings.push({
-                        range: _getStartEnd(name),
-                        moduleName,
-                        isDefaultImport: true,
-                    });
+                    if (componentExtsensions.some(ext => moduleName.endsWith(ext))) {
+                        components.push(_getStartEnd(name));
+                    }
                 }
                 if (namedBindings) {
                     if (ts.isNamedImports(namedBindings)) {
@@ -49,25 +42,27 @@ function parseBindingRanges(ts, ast) {
                             if (element.isTypeOnly) {
                                 continue;
                             }
-                            bindings.push({
-                                range: _getStartEnd(element.name),
-                                moduleName,
-                                isDefaultImport: element.propertyName?.text === 'default',
-                            });
+                            if (element.propertyName
+                                && _getNodeText(element.propertyName) === 'default'
+                                && componentExtsensions.some(ext => moduleName.endsWith(ext))) {
+                                components.push(_getStartEnd(element.name));
+                            }
+                            else {
+                                bindings.push(_getStartEnd(element.name));
+                            }
                         }
                     }
                     else {
-                        bindings.push({
-                            range: _getStartEnd(namedBindings.name),
-                            moduleName,
-                            isNamespace: true,
-                        });
+                        bindings.push(_getStartEnd(namedBindings.name));
                     }
                 }
             }
         }
     });
-    return bindings;
+    return {
+        bindings,
+        components,
+    };
     function _getStartEnd(node) {
         return (0, shared_1.getStartEnd)(ts, node, ast);
     }

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

@@ -35,12 +35,8 @@ function* generate(templateAst) {
                 && prop.name === 'style'
                 && prop.value) {
                 yield `x { `;
-                yield [
-                    prop.value.content,
-                    'template',
-                    (0, shared_1.getAttributeValueOffset)(prop.value),
-                    codeFeatures,
-                ];
+                const [content, offset] = (0, shared_1.normalizeAttributeValue)(prop.value);
+                yield [content, 'template', offset, codeFeatures];
                 yield ` }\n`;
             }
         }

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

@@ -5,7 +5,6 @@ const elementEvents_1 = require("../codegen/template/elementEvents");
 const templateChild_1 = require("../codegen/template/templateChild");
 const vFor_1 = require("../codegen/template/vFor");
 const utils_1 = require("../codegen/utils");
-const computedSfc_1 = require("../virtualFile/computedSfc");
 const codeFeatures = {
     format: true,
 };
@@ -21,7 +20,7 @@ const formatBrackets = {
     event: ['() => ', ';'],
     generic: ['<', '>() => {};'],
 };
-const plugin = ctx => {
+const plugin = ({ modules: { typescript: ts } }) => {
     const parseds = new WeakMap();
     return {
         version: 2.2,
@@ -54,15 +53,14 @@ const plugin = ctx => {
         },
     };
     function parse(sfc) {
-        const data = new Map();
+        const result = new Map();
         if (!sfc.template?.ast) {
-            return data;
+            return result;
         }
-        const templateContent = sfc.template.content;
-        const inlineTsAsts = computedSfc_1.templateInlineTsAsts.get(sfc.template.ast);
+        const template = sfc.template;
         let i = 0;
         sfc.template.ast.children.forEach(visit);
-        return data;
+        return result;
         function visit(node) {
             if (node.type === CompilerDOM.NodeTypes.COMMENT) {
                 const match = node.loc.source.match(/^<!--\s*@vue-generic\s*\{(?<content>[\s\S]*)\}\s*-->$/);
@@ -87,8 +85,8 @@ const plugin = ctx => {
                         && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY // style='z-index: 2' will compile to {'z-index':'2'}
                     ) {
                         if (prop.name === 'on' && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                            const ast = (0, utils_1.createTsAst)(ctx.modules.typescript, inlineTsAsts, prop.exp.content);
-                            if ((0, elementEvents_1.isCompoundExpression)(ctx.modules.typescript, ast)) {
+                            const ast = (0, utils_1.getTypeScriptAST)(ts, template, prop.exp.content);
+                            if ((0, elementEvents_1.isCompoundExpression)(ts, ast)) {
                                 addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.event);
                             }
                             else {
@@ -135,13 +133,13 @@ const plugin = ctx => {
                 if (leftExpressionRange && leftExpressionText && source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
                     let start = leftExpressionRange.start;
                     let end = source.loc.start.offset + source.content.length;
-                    while (templateContent[start - 1] === ' ' || templateContent[start - 1] === '(') {
+                    while (template.content[start - 1] === ' ' || template.content[start - 1] === '(') {
                         start--;
                     }
-                    while (templateContent[end] === ' ' || templateContent[end] === ')') {
+                    while (template.content[end] === ' ' || template.content[end] === ')') {
                         end++;
                     }
-                    addFormatCodes(templateContent.slice(start, end), start, formatBrackets.for);
+                    addFormatCodes(template.content.slice(start, end), start, formatBrackets.for);
                 }
                 for (const child of node.children) {
                     visit(child);
@@ -161,7 +159,7 @@ const plugin = ctx => {
             }
             else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
                 // {{ ... }}
-                const [content, start] = (0, templateChild_1.parseInterpolationNode)(node, templateContent);
+                const [content, start] = (0, templateChild_1.parseInterpolationNode)(node, template.content);
                 const lines = content.split('\n');
                 const firstLineEmpty = lines[0].trim() === '';
                 const lastLineEmpty = lines[lines.length - 1].trim() === '';
@@ -188,7 +186,7 @@ const plugin = ctx => {
         }
         function addFormatCodes(code, offset, wrapper) {
             const id = 'template_inline_ts_' + i++;
-            data.set(id, [
+            result.set(id, [
                 wrapper[0],
                 [
                     code,