@vue/language-core 2.2.0 → 2.2.2

package/lib/codegen/template/templateChild.js

@@ -10,6 +10,7 @@ const interpolation_1 = require("./interpolation");
 const slotOutlet_1 = require("./slotOutlet");
 const vFor_1 = require("./vFor");
 const vIf_1 = require("./vIf");
+const vSlot_1 = require("./vSlot");
 // @ts-ignore
 const transformContext = {
     onError: () => { },
@@ -74,9 +75,15 @@ function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = fals
         else if (vIfNode) {
             yield* (0, vIf_1.generateVIf)(options, ctx, vIfNode);
         }
+        else if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
+            yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node);
+        }
         else {
-            if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
-                yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node);
+            const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
+            if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE
+                && ctx.currentComponent
+                && slotDir) {
+                yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir);
             }
             else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
                 || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {

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

@@ -0,0 +1,5 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateVSlot(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, slotDir: CompilerDOM.DirectiveNode): Generator<Code>;

package/lib/codegen/template/vSlot.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVSlot = generateVSlot;
+const CompilerDOM = require("@vue/compiler-dom");
+const utils_1 = require("../utils");
+const objectProperty_1 = require("./objectProperty");
+const templateChild_1 = require("./templateChild");
+function* generateVSlot(options, ctx, node, slotDir) {
+    if (!ctx.currentComponent) {
+        return;
+    }
+    ctx.currentComponent.used = true;
+    const slotBlockVars = [];
+    yield `{${utils_1.newLine}`;
+    yield `const { `;
+    if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
+    }
+    else {
+        yield* (0, utils_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+    }
+    yield `: __VLS_thisSlot } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
+    if (slotDir.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        const slotAst = (0, utils_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
+        (0, utils_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
+        if (!slotDir.exp.content.includes(':')) {
+            yield `const [`;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield `] = __VLS_getSlotParams(__VLS_thisSlot)${utils_1.endOfLine}`;
+        }
+        else {
+            yield `const `;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield ` = __VLS_getSlotParam(__VLS_thisSlot)${utils_1.endOfLine}`;
+        }
+    }
+    for (const varName of slotBlockVars) {
+        ctx.addLocalVariable(varName);
+    }
+    yield* ctx.resetDirectiveComments('end of slot children start');
+    let prev;
+    for (const childNode of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
+        prev = childNode;
+    }
+    for (const varName of slotBlockVars) {
+        ctx.removeLocalVariable(varName);
+    }
+    let isStatic = true;
+    if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        isStatic = slotDir.arg.isStatic;
+    }
+    if (isStatic && !slotDir.arg) {
+        yield `${ctx.currentComponent.ctxVar}.slots!['`;
+        yield [
+            '',
+            'template',
+            slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+                ? '#'.length
+                : slotDir.loc.source.startsWith('v-slot:')
+                    ? 'v-slot:'.length
+                    : 0),
+            ctx.codeFeatures.completion,
+        ];
+        yield `'/* empty slot name completion */]${utils_1.endOfLine}`;
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield `}${utils_1.newLine}`;
+}
+//# sourceMappingURL=vSlot.js.map

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

@@ -1,3 +1,4 @@
+import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
 import type { Code, SfcBlock, VueCodeInformation } from '../../types';
 export declare const newLine = "\n";
@@ -6,6 +7,15 @@ export declare const combineLastMapping: VueCodeInformation;
 export declare const variableNameRegex: RegExp;
 export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
 export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, results?: string[]): string[];
-export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: [id: ts.Identifier, isRest: boolean][], isRest?: boolean): [id: ts.Identifier, isRest: boolean][];
+export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[], isRest?: boolean, initializer?: ts.Expression | undefined): {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[];
+export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): [string, number];
 export declare function createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;

package/lib/codegen/utils/index.js

@@ -4,6 +4,7 @@ exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exp
 exports.wrapWith = wrapWith;
 exports.collectVars = collectVars;
 exports.collectIdentifiers = collectIdentifiers;
+exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
 const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
@@ -24,18 +25,18 @@ function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
 }
 function collectVars(ts, node, ast, results = []) {
     const identifiers = collectIdentifiers(ts, node, []);
-    for (const [id] of identifiers) {
+    for (const { id } of identifiers) {
         results.push((0, scriptSetupRanges_1.getNodeText)(ts, id, ast));
     }
     return results;
 }
-function collectIdentifiers(ts, node, results = [], isRest = false) {
+function collectIdentifiers(ts, node, results = [], isRest = false, initializer = undefined) {
     if (ts.isIdentifier(node)) {
-        results.push([node, isRest]);
+        results.push({ id: node, isRest, initializer });
     }
     else if (ts.isObjectBindingPattern(node)) {
         for (const el of node.elements) {
-            collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
+            collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken, el.initializer);
         }
     }
     else if (ts.isArrayBindingPattern(node)) {
@@ -50,6 +51,16 @@ function collectIdentifiers(ts, node, results = [], isRest = false) {
     }
     return results;
 }
+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);
+    }
+    return [content, offset];
+}
 function createTsAst(ts, astHolder, text) {
     if (astHolder.__volar_ast_text !== text) {
         astHolder.__volar_ast_text = text;

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

@@ -0,0 +1,2 @@
+import { Code, SfcBlockAttr, VueCodeInformation } from "../../types";
+export declare function generateSfcBlockSrc(src: SfcBlockAttr & object, text: string, features: VueCodeInformation): Generator<Code>;

package/lib/codegen/utils/src.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSfcBlockSrc = generateSfcBlockSrc;
+function* generateSfcBlockSrc(src, text, features) {
+    const { offset, quotes } = src;
+    if (!quotes) {
+        yield [``, 'main', offset, { verification: true }];
+    }
+    yield [
+        quotes ? text : `'${text}'`,
+        'main',
+        quotes ? offset : offset - 1,
+        features
+    ];
+    if (!quotes) {
+        yield [``, 'main', offset + text.length, { __combineOffsetMapping: 2 }];
+    }
+}
+//# sourceMappingURL=src.js.map

package/lib/parsers/scriptSetupRanges.d.ts

@@ -18,11 +18,14 @@ type DefineProp = {
 };
 type DefineProps = CallExpressionRange & {
     name?: string;
-    destructured?: Set<string>;
+    destructured?: Map<string, ts.Expression | undefined>;
     destructuredRest?: string;
     statement: TextRange;
+    argNode?: ts.Expression;
+};
+type WithDefaults = Omit<CallExpressionRange, 'typeArg'> & {
+    argNode?: ts.Expression;
 };
-type WithDefaults = Pick<CallExpressionRange, 'callExp' | 'exp' | 'arg'>;
 type DefineEmits = CallExpressionRange & {
     name?: string;
     hasUnionTypeArg?: boolean;
@@ -30,7 +33,6 @@ type DefineEmits = CallExpressionRange & {
 };
 type DefineSlots = CallExpressionRange & {
     name?: string;
-    isObjectBindingPattern?: boolean;
     statement: TextRange;
 };
 type DefineOptions = {

package/lib/parsers/scriptSetupRanges.js

@@ -197,19 +197,20 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
                 defineProps = {
                     ...parseCallExpression(node),
-                    statement: getStatementRange(ts, parents, node, ast)
+                    statement: getStatementRange(ts, parents, node, ast),
+                    argNode: node.arguments[0]
                 };
                 if (ts.isVariableDeclaration(parent)) {
                     if (ts.isObjectBindingPattern(parent.name)) {
-                        defineProps.destructured = new Set();
+                        defineProps.destructured = new Map();
                         const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name, []);
-                        for (const [id, isRest] of identifiers) {
+                        for (const { id, isRest, initializer } of identifiers) {
                             const name = _getNodeText(id);
                             if (isRest) {
                                 defineProps.destructuredRest = name;
                             }
                             else {
-                                defineProps.destructured.add(name);
+                                defineProps.destructured.set(name, initializer);
                             }
                         }
                     }
@@ -230,7 +231,8 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 withDefaults = {
                     callExp: _getStartEnd(node),
                     exp: _getStartEnd(node.expression),
-                    arg: arg ? _getStartEnd(arg) : undefined
+                    arg: arg ? _getStartEnd(arg) : undefined,
+                    argNode: arg
                 };
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
@@ -259,12 +261,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     statement: getStatementRange(ts, parents, node, ast)
                 };
                 if (ts.isVariableDeclaration(parent)) {
-                    if (ts.isIdentifier(parent.name)) {
-                        defineSlots.name = _getNodeText(parent.name);
-                    }
-                    else {
-                        defineSlots.isObjectBindingPattern = ts.isObjectBindingPattern(parent.name);
-                    }
+                    defineSlots.name = _getNodeText(parent.name);
                 }
             }
             else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {

package/lib/parsers/vueCompilerOptions.d.ts

@@ -1,2 +1,2 @@
-import type { VueCompilerOptions } from '../types';
-export declare function parseVueCompilerOptions(comments: string[]): Partial<VueCompilerOptions> | undefined;
+import type { RawVueCompilerOptions } from '../types';
+export declare function parseVueCompilerOptions(comments: string[]): RawVueCompilerOptions | undefined;

package/lib/plugins/vue-style-class-names.d.ts

@@ -0,0 +1,5 @@
+import type { VueLanguagePlugin } from '../types';
+export declare const commentReg: RegExp;
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+export declare function fillBlank(css: string, ...regs: RegExp[]): string;

package/lib/plugins/vue-style-class-names.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commentReg = void 0;
+exports.fillBlank = fillBlank;
+exports.commentReg = /(?<=\/\*)[\s\S]*?(?=\*\/)|(?<=\/\/)[\s\S]*?(?=\n)/g;
+const cssClassNameReg = /(?=(\.[a-z_][-\w]*)[\s.,+~>:#)[{])/gi;
+const fragmentReg = /(?<={)[^{]*(?=(?<!\\);)/g;
+const plugin = () => {
+    return {
+        version: 2.1,
+        resolveStyleReferenceLinks(block) {
+            const result = [];
+            const content = fillBlank(block.content, exports.commentReg, fragmentReg);
+            const matches = content.matchAll(cssClassNameReg);
+            for (const match of matches) {
+                const matchText = match[1];
+                if (matchText) {
+                    result.push({ text: matchText, offset: match.index });
+                }
+            }
+            return result;
+        },
+    };
+};
+exports.default = plugin;
+function fillBlank(css, ...regs) {
+    for (const reg of regs) {
+        css = css.replace(reg, match => ' '.repeat(match.length));
+    }
+    return css;
+}
+//# sourceMappingURL=vue-style-class-names.js.map

package/lib/plugins/vue-style-reference-link.d.ts

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

package/lib/plugins/vue-style-reference-link.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=vue-style-reference-link.js.map

package/lib/plugins/vue-style-reference-links.d.ts

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

package/lib/plugins/vue-style-reference-links.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cssImportReg = /(?<=@import\s+url\()(["']?).*?\1(?=\))|(?<=@import\b\s*)(["']).*?\2/g;
+const plugin = () => {
+    return {
+        version: 2.1,
+        resolveStyleReferenceLinks(block) {
+            const result = [];
+            const matches = block.content.matchAll(cssImportReg);
+            for (const match of matches) {
+                let text = match[0];
+                let offset = match.index;
+                if (text.startsWith('\'') || text.startsWith('"')) {
+                    text = text.slice(1, -1);
+                    offset += 1;
+                }
+                if (text) {
+                    result.push({ text, offset });
+                }
+            }
+            return result;
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-style-reference-links.js.map

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

@@ -76,19 +76,37 @@ const plugin = ctx => {
                         continue;
                     }
                     if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && !prop.arg.isStatic) {
-                        addFormatCodes(prop.arg.content, prop.arg.loc.start.offset, formatBrackets.normal);
+                        addFormatCodes(prop.arg.loc.source, prop.arg.loc.start.offset, formatBrackets.normal);
                     }
                     if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
                         && 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, prop.exp, prop.exp.content);
-                            addFormatCodes(prop.exp.content, prop.exp.loc.start.offset, (0, elementEvents_1.isCompoundExpression)(ctx.modules.typescript, ast)
-                                ? formatBrackets.event
-                                : formatBrackets.normal);
+                            if ((0, elementEvents_1.isCompoundExpression)(ctx.modules.typescript, ast)) {
+                                addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.event);
+                            }
+                            else {
+                                const lines = prop.exp.content.split('\n');
+                                const firstLineEmpty = lines[0].trim() === '';
+                                const lastLineEmpty = lines[lines.length - 1].trim() === '';
+                                if (lines.length <= 1 || (!firstLineEmpty && !lastLineEmpty)) {
+                                    addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.normal);
+                                }
+                                else {
+                                    addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, ['(', ');']);
+                                }
+                            }
+                        }
+                        else if (prop.name === 'slot') {
+                            addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.params);
+                        }
+                        else if (prop.rawName === 'v-for') {
+                            // #2586
+                            addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.for);
                         }
                         else {
-                            addFormatCodes(prop.exp.content, prop.exp.loc.start.offset, formatBrackets.normal);
+                            addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.normal);
                         }
                     }
                 }
@@ -100,7 +118,7 @@ const plugin = ctx => {
                 for (let i = 0; i < node.branches.length; i++) {
                     const branch = node.branches[i];
                     if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                        addFormatCodes(branch.condition.content, branch.condition.loc.start.offset, formatBrackets.if);
+                        addFormatCodes(branch.condition.loc.source, branch.condition.loc.start.offset, formatBrackets.if);
                     }
                     for (const childNode of branch.children) {
                         visit(childNode);
@@ -111,8 +129,14 @@ const plugin = ctx => {
                 const { leftExpressionRange, leftExpressionText } = (0, vFor_1.parseVForNode)(node);
                 const { source } = node.parseResult;
                 if (leftExpressionRange && leftExpressionText && source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                    const start = leftExpressionRange.start;
-                    const end = source.loc.start.offset + source.content.length;
+                    let start = leftExpressionRange.start;
+                    let end = source.loc.start.offset + source.content.length;
+                    while (templateContent[start - 1] === ' ' || templateContent[start - 1] === '(') {
+                        start--;
+                    }
+                    while (templateContent[end] === ' ' || templateContent[end] === ')') {
+                        end++;
+                    }
                     addFormatCodes(templateContent.slice(start, end), start, formatBrackets.for);
                 }
                 for (const child of node.children) {
@@ -135,10 +159,27 @@ const plugin = ctx => {
                 // {{ ... }}
                 const [content, start] = (0, templateChild_1.parseInterpolationNode)(node, templateContent);
                 const lines = content.split('\n');
-                addFormatCodes(content, start, lines.length <= 1 ? formatBrackets.curly : [
-                    lines[0].trim() === '' ? '(' : formatBrackets.curly[0],
-                    lines[lines.length - 1].trim() === '' ? ');' : formatBrackets.curly[1],
-                ]);
+                const firstLineEmpty = lines[0].trim() === '';
+                const lastLineEmpty = lines[lines.length - 1].trim() === '';
+                if (content.includes('=>')) { // arrow function
+                    if (lines.length <= 1 || (!firstLineEmpty && !lastLineEmpty)) {
+                        addFormatCodes(content, start, formatBrackets.normal);
+                    }
+                    else {
+                        addFormatCodes(content, start, ['(', ');']);
+                    }
+                }
+                else {
+                    if (lines.length <= 1 || (!firstLineEmpty && !lastLineEmpty)) {
+                        addFormatCodes(content, start, formatBrackets.curly);
+                    }
+                    else {
+                        addFormatCodes(content, start, [
+                            firstLineEmpty ? '(' : '(0 +',
+                            lastLineEmpty ? ');' : '+ 0);'
+                        ]);
+                    }
+                }
             }
         }
         function addFormatCodes(code, offset, wrapper) {

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

@@ -1,7 +1,7 @@
 import type { Mapping } from '@volar/language-core';
 import type { Code, Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
-    scriptRanges: import("alien-signals").Computed<{
+    getScriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
             args: import("../types").TextRange;
@@ -19,8 +19,8 @@ export declare const tsCodegen: WeakMap<Sfc, {
             isDefaultImport?: boolean;
             isNamespace?: boolean;
         }[];
-    } | undefined>;
-    scriptSetupRanges: import("alien-signals").Computed<{
+    } | undefined;
+    getScriptSetupRanges: () => {
         leadingCommentEndOffset: number;
         importSectionEndOffset: number;
         bindings: {
@@ -46,15 +46,19 @@ export declare const tsCodegen: WeakMap<Sfc, {
             typeArg?: import("../types").TextRange;
         } & {
             name?: string;
-            destructured?: Set<string>;
+            destructured?: Map<string, import("typescript").Expression | undefined>;
             destructuredRest?: string;
             statement: import("../types").TextRange;
+            argNode?: import("typescript").Expression;
         }) | undefined;
-        withDefaults: {
+        withDefaults: (Omit<{
             callExp: import("../types").TextRange;
             exp: import("../types").TextRange;
-            arg?: import("../types").TextRange | undefined;
-        } | undefined;
+            arg?: import("../types").TextRange;
+            typeArg?: import("../types").TextRange;
+        }, "typeArg"> & {
+            argNode?: import("typescript").Expression;
+        }) | undefined;
         defineEmits: ({
             callExp: import("../types").TextRange;
             exp: import("../types").TextRange;
@@ -72,7 +76,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
             typeArg?: import("../types").TextRange;
         } & {
             name?: string;
-            isObjectBindingPattern?: boolean;
             statement: import("../types").TextRange;
         }) | undefined;
         defineExpose: {
@@ -111,9 +114,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
         } & {
             name?: string;
         })[];
-    } | undefined>;
-    lang: import("alien-signals").Computed<string>;
-    generatedScript: import("alien-signals").Computed<{
+    } | undefined;
+    getLang: () => string;
+    getGeneratedScript: () => {
         codes: Code[];
         linkedCodeMappings: Mapping<unknown>[];
         generatedTemplate: boolean;
@@ -127,46 +130,51 @@ export declare const tsCodegen: WeakMap<Sfc, {
             readonly PrettifyLocal: string;
             readonly OmitKeepDiscriminatedUnion: string;
             readonly WithDefaults: string;
-            readonly WithTemplateSlots: string;
+            readonly WithSlots: string;
             readonly PropsChildren: string;
             readonly TypePropsToOption: string;
             readonly OmitIndexSignature: string;
         };
         inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
-    }>;
-    generatedTemplate: import("alien-signals").Computed<{
+    };
+    getGeneratedTemplate: () => {
         codes: Code[];
-        slots: {
-            name: string;
-            loc?: number;
-            tagRange: [number, number];
-            varName: string;
-            nodeLoc: any;
-        }[];
-        dynamicSlots: {
-            expVar: string;
-            varName: string;
-        }[];
         codeFeatures: {
             all: import("../types").VueCodeInformation;
+            none: import("../types").VueCodeInformation;
             verification: import("../types").VueCodeInformation;
             completion: import("../types").VueCodeInformation;
             additionalCompletion: import("../types").VueCodeInformation;
+            withoutCompletion: import("../types").VueCodeInformation;
             navigation: import("../types").VueCodeInformation;
             navigationWithoutRename: import("../types").VueCodeInformation;
             navigationAndCompletion: import("../types").VueCodeInformation;
             navigationAndAdditionalCompletion: import("../types").VueCodeInformation;
+            navigationAndVerification: import("../types").VueCodeInformation;
             withoutNavigation: import("../types").VueCodeInformation;
             withoutHighlight: import("../types").VueCodeInformation;
+            withoutHighlightAndNavigation: import("../types").VueCodeInformation;
             withoutHighlightAndCompletion: import("../types").VueCodeInformation;
             withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
         };
+        resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
+        slots: {
+            name: string;
+            offset?: number;
+            tagRange: [number, number];
+            nodeLoc: any;
+            propsVar: string;
+        }[];
+        dynamicSlots: {
+            expVar: string;
+            propsVar: string;
+        }[];
+        specialVars: Set<string>;
         accessExternalVariables: Map<string, Set<number>>;
         lastGenericComment: {
             content: string;
             offset: number;
         } | undefined;
-        hasSlotElements: Set<import("@vue/compiler-dom").ElementNode>;
         blockConditions: string[];
         scopedClasses: {
             source: string;
@@ -180,7 +188,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
         inheritedAttrVars: Set<string>;
         templateRefs: Map<string, [varName: string, offset: number]>;
         currentComponent: {
-            node: import("@vue/compiler-dom").ElementNode;
             ctxVar: string;
             used: boolean;
         } | undefined;
@@ -195,7 +202,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
         expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code>;
         resetDirectiveComments: (endStr: string) => Generator<Code>;
         generateAutoImportCompletion: () => Generator<Code>;
-    } | undefined>;
+    } | undefined;
 }>;
 declare const plugin: VueLanguagePlugin;
 export default plugin;