@vue/language-core 3.1.4 → 3.1.6

package/lib/codegen/utils/escaped.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateEscaped = generateEscaped;
 function* generateEscaped(text, source, offset, features, escapeTarget) {
     const parts = text.split(escapeTarget);
-    const startCombineOffset = features.__combineOffset ?? 0;
+    const combineToken = features.__combineToken ?? Symbol();
     let isEscapeTarget = false;
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
@@ -14,7 +14,9 @@ function* generateEscaped(text, source, offset, features, escapeTarget) {
             part,
             source,
             offset,
-            i === 0 ? features : { __combineOffset: startCombineOffset + i },
+            i === 0
+                ? { ...features, __combineToken: combineToken }
+                : { __combineToken: combineToken },
         ];
         offset += part.length;
         isEscapeTarget = !isEscapeTarget;

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

@@ -1,11 +1,8 @@
-import type * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
 import type { Code, SfcBlock, VueCodeInformation } from '../../types';
 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): 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>;
+export declare function getTypeScriptAST(ts: typeof import('typescript'), block: SfcBlock, text: string): ts.SourceFile;
+export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation, partiallyEnd?: boolean): Generator<Code>;
+export declare function forEachNode(ts: typeof import('typescript'), node: ts.Node): Generator<ts.Node>;

package/lib/codegen/utils/index.js

@@ -1,45 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.identifierRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
-exports.normalizeAttributeValue = normalizeAttributeValue;
-exports.createTsAst = createTsAst;
+exports.identifierRegex = exports.endOfLine = exports.newLine = void 0;
+exports.getTypeScriptAST = getTypeScriptAST;
 exports.generateSfcBlockSection = generateSfcBlockSection;
-exports.generatePartiallyEnding = generatePartiallyEnding;
+exports.forEachNode = forEachNode;
 const codeFeatures_1 = require("../codeFeatures");
 exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
-exports.combineLastMapping = { __combineOffset: 1 };
 exports.identifierRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-function normalizeAttributeValue(node) {
-    let offset = node.loc.start.offset;
-    let content = node.loc.source;
-    if ((content.startsWith(`'`) && content.endsWith(`'`))
-        || (content.startsWith(`"`) && content.endsWith(`"`))) {
-        offset++;
-        content = content.slice(1, -1);
+const cacheMaps = new Map();
+function getTypeScriptAST(ts, block, text) {
+    if (!cacheMaps.has(block)) {
+        cacheMaps.set(block, [block.content, new Map()]);
     }
-    return [content, offset];
-}
-function createTsAst(ts, inlineTsAsts, text) {
-    let ast = inlineTsAsts?.get(text);
-    if (!ast) {
-        ast = ts.createSourceFile('/a.ts', text, 99);
-        inlineTsAsts?.set(text, ast);
+    const cacheMap = cacheMaps.get(block);
+    if (cacheMap[0] !== block.content) {
+        cacheMap[0] = block.content;
+        for (const [key, info] of cacheMap[1]) {
+            if (info[1]) {
+                info[1] = 0;
+            }
+            else {
+                cacheMap[1].delete(key);
+            }
+        }
+    }
+    const cache = cacheMap[1].get(text);
+    if (cache) {
+        cache[1]++;
+        return cache[0];
     }
-    ast.__volar_used = true;
+    const ast = ts.createSourceFile('/dummy.ts', text, 99);
+    cacheMap[1].set(text, [ast, 1]);
     return ast;
 }
-function generateSfcBlockSection(block, start, end, features) {
-    return [
+function* generateSfcBlockSection(block, start, end, features, partiallyEnd = false) {
+    yield [
         block.content.slice(start, end),
         block.name,
         start,
         features,
     ];
+    // #3632
+    if (partiallyEnd) {
+        yield `;`;
+        yield ['', block.name, end, codeFeatures_1.codeFeatures.verification];
+        yield exports.newLine;
+    }
 }
-function* generatePartiallyEnding(source, end, mark, delimiter = 'debugger') {
-    yield delimiter;
-    yield [``, source, end, codeFeatures_1.codeFeatures.verification];
-    yield `/* PartiallyEnd: ${mark} */${exports.newLine}`;
+function* forEachNode(ts, node) {
+    const children = [];
+    ts.forEachChild(node, child => {
+        children.push(child);
+    });
+    for (const child of children) {
+        yield child;
+    }
 }
 //# sourceMappingURL=index.js.map

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)(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)(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.js

@@ -24,7 +24,8 @@ function createParsedCommandLineByJson(ts, host, rootDir, json, configFileName)
             return [];
         },
     };
-    const parsed = ts.parseJsonConfigFileContent(json, proxyHost, rootDir, {}, configFileName);
+    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 {
@@ -35,8 +36,7 @@ function createParsedCommandLineByJson(ts, host, rootDir, json, configFileName)
         }
         catch { }
     }
-    // ensure the rootDir is added to the config roots
-    resolver.addConfig({}, rootDir);
+    resolver.addConfig(json?.vueCompilerOptions ?? {}, rootDir);
     return {
         ...parsed,
         vueOptions: resolver.build(),
@@ -151,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,33 +6,22 @@ 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 fileRegistries = [];
-function getVueFileRegistry(key, plugins) {
-    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 = [
+const virtualCode_1 = require("./virtualCode");
+const fileRegistries = {};
+function getVueFileRegistry(compilerOptions, vueCompilerOptions, plugins) {
+    const key = JSON.stringify([
+        ...plugins.map(plugin => plugin.name)
+            .filter(name => typeof name === 'string')
+            .sort(),
         ...Object.keys(vueCompilerOptions)
-            .sort()
             .filter(key => key !== 'plugins')
+            .sort()
             .map(key => [key, vueCompilerOptions[key]]),
-        [...new Set(plugins.map(plugin => plugin.requiredCompilerOptions ?? []).flat())]
+        ...[...new Set(plugins.flatMap(plugin => plugin.requiredCompilerOptions ?? []))]
             .sort()
             .map(key => [key, compilerOptions[key]]),
-    ];
-    return JSON.stringify(values);
+    ]);
+    return fileRegistries[key] ??= new Map();
 }
 function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFileName) {
     const pluginContext = {
@@ -44,7 +33,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
         vueCompilerOptions,
     };
     const plugins = (0, plugins_1.createPlugins)(pluginContext);
-    const fileRegistry = getVueFileRegistry(getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins), vueCompilerOptions.plugins);
+    const fileRegistry = getVueFileRegistry(compilerOptions, vueCompilerOptions, plugins);
     return {
         getLanguageId(scriptId) {
             const fileName = asFileName(scriptId);
@@ -64,16 +53,20 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
                     return code;
                 }
                 else {
-                    const code = new vueFile_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
+                    const code = new virtualCode_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
                     fileRegistry.set(fileName, code);
                     return code;
                 }
             }
         },
-        updateVirtualCode(_fileId, code, snapshot) {
+        updateVirtualCode(_scriptId, code, snapshot) {
             code.update(snapshot);
             return code;
         },
+        disposeVirtualCode(scriptId) {
+            const fileName = asFileName(scriptId);
+            fileRegistry.delete(fileName);
+        },
         typescript: {
             extraFileExtensions: getAllExtensions(vueCompilerOptions)
                 .map(ext => ({

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

@@ -2,38 +2,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const shouldAddSuffix = /(?<=<[^>/]+)$/;
 const plugin = ({ modules }) => {
+    const CompilerDOM = modules['@vue/compiler-dom'];
     return {
         version: 2.2,
         compileSFCTemplate(lang, template, options) {
             if (lang === 'html' || lang === 'md') {
-                const compiler = modules['@vue/compiler-dom'];
                 let addedSuffix = false;
                 // #4583
                 if (shouldAddSuffix.test(template)) {
                     template += '>';
                     addedSuffix = true;
                 }
-                const result = compiler.compile(template, {
+                const ast = CompilerDOM.parse(template, {
                     ...options,
                     comments: true,
                 });
-                // @ts-expect-error
-                result.__addedSuffix = addedSuffix;
-                return result;
+                CompilerDOM.transform(ast, options);
+                return {
+                    ast,
+                    code: '',
+                    preamble: '',
+                    __addedSuffix: addedSuffix,
+                };
             }
         },
         updateSFCTemplate(oldResult, change) {
-            oldResult.code = oldResult.code.slice(0, change.start)
+            const newSource = oldResult.ast.source.slice(0, change.start)
                 + change.newText
-                + oldResult.code.slice(change.end);
+                + oldResult.ast.source.slice(change.end);
             // @ts-expect-error
             if (oldResult.__addedSuffix) {
-                const originalTemplate = oldResult.code.slice(0, -1); // remove added '>'
+                const originalTemplate = newSource.slice(0, -1); // remove added '>'
                 if (!shouldAddSuffix.test(originalTemplate)) {
                     return undefined;
                 }
             }
-            const CompilerDOM = modules['@vue/compiler-dom'];
             const lengthDiff = change.newText.length - (change.end - change.start);
             let hitNodes = [];
             if (tryUpdateNode(oldResult.ast) && hitNodes.length) {

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

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const CompilerDOM = require("@vue/compiler-dom");
 const forEachTemplateNode_1 = require("../utils/forEachTemplateNode");
-const shared_1 = require("./shared");
+const shared_1 = require("../utils/shared");
+const shared_2 = require("./shared");
 const codeFeatures = {
-    ...shared_1.allCodeFeatures,
+    ...shared_2.allCodeFeatures,
     format: false,
     structure: false,
 };
@@ -30,23 +31,12 @@ exports.default = plugin;
 function* generate(templateAst) {
     for (const node of (0, forEachTemplateNode_1.forEachElementNode)(templateAst)) {
         for (const prop of node.props) {
-            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-                && prop.name === 'bind'
-                && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                && prop.arg.content === 'style'
-                && prop.exp.constType === CompilerDOM.ConstantTypes.CAN_STRINGIFY) {
-                const endCrt = prop.arg.loc.source[prop.arg.loc.source.length - 1]; // " | '
-                const start = prop.arg.loc.source.indexOf(endCrt) + 1;
-                const end = prop.arg.loc.source.lastIndexOf(endCrt);
-                const content = prop.arg.loc.source.slice(start, end);
+            if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+                && prop.name === 'style'
+                && prop.value) {
                 yield `x { `;
-                yield [
-                    content,
-                    'template',
-                    prop.arg.loc.start.offset + start,
-                    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,

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

@@ -1,6 +1,5 @@
 import type { Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
-    getLang: () => string;
     getScriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
@@ -121,14 +120,11 @@ export declare const tsCodegen: WeakMap<Sfc, {
     getSetupSlotsAssignName: () => string | undefined;
     getGeneratedScript: () => {
         codes: import("../types").Code[];
-        generatedTemplate: boolean;
-        generatedPropsType: boolean;
-        bypassDefineComponent: boolean;
-        bindingNames: Set<string>;
+        generatedTypes: Set<string>;
         localTypes: {
             generate: () => Generator<string, void, unknown>;
             readonly PrettifyLocal: string;
-            readonly WithDefaultsLocal: string;
+            readonly WithDefaults: string;
             readonly WithSlots: string;
             readonly PropsChildren: string;
             readonly TypePropsToOption: string;
@@ -138,6 +134,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
     };
     getGeneratedTemplate: () => {
         codes: import("../types").Code[];
+        generatedTypes: Set<string>;
         currentInfo: {
             ignoreError?: boolean;
             expectError?: {
@@ -150,7 +147,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
             };
         };
         resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
-        inlineTsAsts: Map<string, import("typescript").SourceFile> | undefined;
         inVFor: boolean;
         slots: {
             name: string;
@@ -164,40 +160,35 @@ export declare const tsCodegen: WeakMap<Sfc, {
             propsVar: string;
         }[];
         dollarVars: Set<string>;
-        accessExternalVariables: Map<string, Set<number>>;
+        componentAccessMap: Map<string, Map<string, Set<number>>>;
         blockConditions: string[];
-        scopedClasses: {
-            source: string;
-            className: string;
-            offset: number;
-        }[];
-        emptyClassOffsets: number[];
         inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
-        bindingAttrLocs: import("@vue/compiler-dom").SourceLocation[];
         inheritedAttrVars: Set<string>;
         templateRefs: Map<string, {
             typeExp: string;
             offset: number;
         }[]>;
         currentComponent: {
-            ctxVar: string;
-            used: boolean;
+            get ctxVar(): string;
+            get propsVar(): string;
         } | undefined;
-        singleRootElTypes: string[];
+        singleRootElTypes: Set<string>;
         singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
         addTemplateRef(name: string, typeExp: string, offset: number): void;
-        accessExternalVariable(name: string, offset?: number): void;
-        hasLocalVariable(name: string): boolean;
-        addLocalVariable(name: string): void;
-        removeLocalVariable(name: string): void;
+        recordComponentAccess(source: string, name: string, offset?: number): void;
+        scopes: Set<string>[];
+        declare(...varNames: string[]): void;
+        startScope(): () => Generator<import("../types").Code, any, any>;
         getInternalVariable(): string;
         getHoistVariable(originalVar: string): string;
         generateHoistVariables(): Generator<string, void, unknown>;
         generateConditionGuards(): Generator<string, void, unknown>;
-        generateAutoImportCompletion(): Generator<import("../types").Code>;
         enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
         exit(): Generator<import("../types").Code>;
     } | undefined;
+    getImportComponentNames: () => Set<string>;
+    getSetupExposed: () => Set<string>;
+    getSetupConsts: () => Set<string>;
 }>;
 declare const plugin: VueLanguagePlugin;
 export default plugin;