@vue/language-core 3.0.4 → 3.0.5

package/lib/codegen/codeFeatures.d.ts

@@ -25,15 +25,16 @@ declare const raw: {
     navigation: {
         navigation: true;
     };
+    navigationWithoutHighlight: {
+        navigation: {
+            shouldHighlight: () => false;
+        };
+    };
     navigationWithoutRename: {
         navigation: {
             shouldRename: () => false;
         };
     };
-    navigationAndCompletion: {
-        navigation: true;
-        completion: true;
-    };
     navigationAndAdditionalCompletion: {
         navigation: true;
         completion: {
@@ -62,13 +63,6 @@ declare const raw: {
         navigation: true;
         completion: true;
     };
-    withoutHighlightAndNavigation: {
-        semantic: {
-            shouldHighlight: () => false;
-        };
-        verification: true;
-        completion: true;
-    };
     withoutHighlightAndCompletion: {
         semantic: {
             shouldHighlight: () => false;
@@ -76,12 +70,6 @@ declare const raw: {
         verification: true;
         navigation: true;
     };
-    withoutHighlightAndCompletionAndNavigation: {
-        semantic: {
-            shouldHighlight: () => false;
-        };
-        verification: true;
-    };
     withoutSemantic: {
         verification: true;
         navigation: true;

package/lib/codegen/codeFeatures.js

@@ -25,13 +25,12 @@ const raw = {
     navigation: {
         navigation: true,
     },
+    navigationWithoutHighlight: {
+        navigation: { shouldHighlight: () => false },
+    },
     navigationWithoutRename: {
         navigation: { shouldRename: () => false },
     },
-    navigationAndCompletion: {
-        navigation: true,
-        completion: true,
-    },
     navigationAndAdditionalCompletion: {
         navigation: true,
         completion: { isAdditional: true },
@@ -54,20 +53,11 @@ const raw = {
         navigation: true,
         completion: true,
     },
-    withoutHighlightAndNavigation: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-        completion: true,
-    },
     withoutHighlightAndCompletion: {
         semantic: { shouldHighlight: () => false },
         verification: true,
         navigation: true,
     },
-    withoutHighlightAndCompletionAndNavigation: {
-        semantic: { shouldHighlight: () => false },
-        verification: true,
-    },
     withoutSemantic: {
         verification: true,
         navigation: true,

package/lib/codegen/script/context.d.ts

@@ -1,11 +1,5 @@
 import type { InlayHintInfo } from '../inlayHints';
 import type { ScriptCodegenOptions } from './index';
-export interface HelperType {
-    name: string;
-    used?: boolean;
-    generated?: boolean;
-    code: string;
-}
 export type ScriptCodegenContext = ReturnType<typeof createScriptCodegenContext>;
 export declare function createScriptCodegenContext(options: ScriptCodegenOptions): {
     generatedTemplate: boolean;

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

@@ -4,6 +4,7 @@ import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
 import type { Code, Sfc, VueCompilerOptions } from '../../types';
 import type { TemplateCodegenContext } from '../template/context';
 import { type ScriptCodegenContext } from './context';
+export * from './context';
 export interface ScriptCodegenOptions {
     ts: typeof ts;
     compilerOptions: ts.CompilerOptions;
@@ -19,5 +20,5 @@ export interface ScriptCodegenOptions {
     destructuredPropNames: Set<string>;
     templateRefNames: Set<string>;
 }
-export declare function generateScript(options: ScriptCodegenOptions): Generator<Code, ScriptCodegenContext>;
+export declare function generateScript(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code>;
 export declare function generateScriptSectionPartiallyEnding(source: string, end: number, mark: string, delimiter?: string): Generator<Code>;

package/lib/codegen/script/index.js

@@ -1,4 +1,18 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateScript = generateScript;
 exports.generateScriptSectionPartiallyEnding = generateScriptSectionPartiallyEnding;
@@ -6,12 +20,11 @@ const path = require("path-browserify");
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const componentSelf_1 = require("./componentSelf");
-const context_1 = require("./context");
 const scriptSetup_1 = require("./scriptSetup");
 const src_1 = require("./src");
 const template_1 = require("./template");
-function* generateScript(options) {
-    const ctx = (0, context_1.createScriptCodegenContext)(options);
+__exportStar(require("./context"), exports);
+function* generateScript(options, ctx) {
     yield* generateGlobalTypesPath(options);
     if (options.sfc.script?.src) {
         yield* (0, src_1.generateSrc)(options.sfc.script.src);
@@ -93,7 +106,6 @@ function* generateScript(options) {
     if (options.sfc.scriptSetup) {
         yield ['', 'scriptSetup', options.sfc.scriptSetup.content.length, codeFeatures_1.codeFeatures.verification];
     }
-    return ctx;
 }
 function* generateGlobalTypesPath(options) {
     const globalTypesPath = options.vueCompilerOptions.globalTypesPath(options.fileName);

package/lib/codegen/script/scriptSetup.js

@@ -400,7 +400,7 @@ function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges) {
             yield* generateDefineModelType(scriptSetup, propName, localName, defineModel);
             yield `,${utils_1.newLine}`;
             if (defineModel.modifierType) {
-                const modifierName = `${defineModel.name ? propName : 'model'}Modifiers`;
+                const modifierName = `${propName === 'modelValue' ? 'model' : propName}Modifiers`;
                 const modifierType = getRangeText(scriptSetup, defineModel.modifierType);
                 yield `'${modifierName}'?: Partial<Record<${modifierType}, true>>,${utils_1.newLine}`;
             }

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

@@ -112,28 +112,6 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
             offset: number;
         };
     };
-    codeFeatures: {
-        all: VueCodeInformation;
-        verification: VueCodeInformation;
-        completion: VueCodeInformation;
-        additionalCompletion: VueCodeInformation;
-        withoutCompletion: VueCodeInformation;
-        navigation: VueCodeInformation;
-        navigationWithoutRename: VueCodeInformation;
-        navigationAndCompletion: VueCodeInformation;
-        navigationAndAdditionalCompletion: VueCodeInformation;
-        navigationAndVerification: VueCodeInformation;
-        withoutNavigation: VueCodeInformation;
-        semanticWithoutHighlight: VueCodeInformation;
-        withoutHighlight: VueCodeInformation;
-        withoutHighlightAndNavigation: VueCodeInformation;
-        withoutHighlightAndCompletion: VueCodeInformation;
-        withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
-        withoutSemantic: VueCodeInformation;
-        doNotReportTs2339AndTs2551: VueCodeInformation;
-        doNotReportTs2353AndTs2561: VueCodeInformation;
-        doNotReportTs6133: VueCodeInformation;
-    };
     resolveCodeFeatures: (features: VueCodeInformation) => VueCodeInformation;
     inlineTsAsts: Map<string, import("typescript").SourceFile> | undefined;
     inVFor: boolean;

package/lib/codegen/template/context.js

@@ -154,12 +154,6 @@ function createTemplateCodegenContext(options, templateAst) {
         get currentInfo() {
             return stack[stack.length - 1];
         },
-        codeFeatures: new Proxy(codeFeatures_1.codeFeatures, {
-            get(target, key) {
-                const data = target[key];
-                return resolveCodeFeatures(data);
-            },
-        }),
         resolveCodeFeatures,
         inlineTsAsts: templateAst && computedSfc_1.templateInlineTsAsts.get(templateAst),
         inVFor: false,

package/lib/codegen/template/element.js

@@ -76,12 +76,12 @@ function* generateComponent(options, ctx, node) {
                     componentOriginalVar,
                     'template',
                     tagOffset,
-                    ctx.codeFeatures.withoutHighlightAndCompletion,
+                    codeFeatures_1.codeFeatures.withoutHighlightAndCompletion,
                 ];
             }
             else {
                 const shouldCapitalize = matchImportName[0].toUpperCase() === matchImportName[0];
-                yield* (0, camelized_1.generateCamelized)(shouldCapitalize ? (0, shared_1.capitalize)(node.tag) : node.tag, 'template', tagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
+                yield* (0, camelized_1.generateCamelized)(shouldCapitalize ? (0, shared_1.capitalize)(node.tag) : node.tag, 'template', tagOffset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
             }
             yield `, `;
         }
@@ -89,10 +89,10 @@ function* generateComponent(options, ctx, node) {
     }
     else if (dynamicTagInfo) {
         yield `const ${componentOriginalVar} = (`;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, dynamicTagInfo.tag, dynamicTagInfo.offsets[0], `(`, `)`);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.all, dynamicTagInfo.tag, dynamicTagInfo.offsets[0], `(`, `)`);
         if (dynamicTagInfo.offsets[1] !== undefined) {
             yield `,`;
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.withoutCompletion, dynamicTagInfo.tag, dynamicTagInfo.offsets[1], `(`, `)`);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.withoutCompletion, dynamicTagInfo.tag, dynamicTagInfo.offsets[1], `(`, `)`);
         }
         yield `)${utils_1.endOfLine}`;
     }
@@ -110,12 +110,12 @@ function* generateComponent(options, ctx, node) {
             .map(name => `'${name}'`)
             .join(`, `);
         yield `>).`;
-        yield* generateCanonicalComponentName(node.tag, tagOffsets[0], ctx.resolveCodeFeatures({
+        yield* generateCanonicalComponentName(node.tag, tagOffsets[0], {
             ...codeFeatures_1.codeFeatures.semanticWithoutHighlight,
             ...options.vueCompilerOptions.checkUnknownComponents
                 ? codeFeatures_1.codeFeatures.verification
                 : codeFeatures_1.codeFeatures.doNotReportTs2339AndTs2551,
-        }));
+        });
         yield `${utils_1.endOfLine}`;
         const camelizedTag = (0, shared_1.camelize)(node.tag);
         if (utils_1.identifierRegex.test(camelizedTag)) {
@@ -145,11 +145,11 @@ function* generateComponent(options, ctx, node) {
     yield* (0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.checkUnknownProps, false);
     yield `}))${utils_1.endOfLine}`;
     yield `const `;
-    yield* (0, wrapWith_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.doNotReportTs6133, componentVNodeVar);
+    yield* (0, wrapWith_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, codeFeatures_1.codeFeatures.doNotReportTs6133, componentVNodeVar);
     yield ` = ${componentFunctionalVar}`;
     yield* generateComponentGeneric(ctx);
     yield `(`;
-    yield* (0, wrapWith_1.wrapWith)(tagOffsets[0], tagOffsets[0] + node.tag.length, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.checkUnknownProps, true, failedPropExps), `}`);
+    yield* (0, wrapWith_1.wrapWith)(tagOffsets[0], tagOffsets[0] + node.tag.length, codeFeatures_1.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, props, options.vueCompilerOptions.checkUnknownProps, true, failedPropExps), `}`);
     yield `, ...__VLS_functionalComponentArgsRest(${componentFunctionalVar}))${utils_1.endOfLine}`;
     yield* generateFailedPropExps(options, ctx, failedPropExps);
     yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, componentOriginalVar, componentFunctionalVar, componentVNodeVar, componentCtxVar);
@@ -192,14 +192,18 @@ function* generateElement(options, ctx, node) {
         ? node.loc.start.offset + node.loc.source.lastIndexOf(node.tag)
         : undefined;
     const failedPropExps = [];
+    const features = {
+        ...codeFeatures_1.codeFeatures.semanticWithoutHighlight,
+        ...codeFeatures_1.codeFeatures.navigationWithoutHighlight,
+    };
     yield `__VLS_asFunctionalElement(__VLS_elements`;
-    yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, startTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
+    yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, startTagOffset, features);
     if (endTagOffset !== undefined) {
         yield `, __VLS_elements`;
-        yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, endTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
+        yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, endTagOffset, features);
     }
     yield `)(`;
-    yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props, options.vueCompilerOptions.checkUnknownProps, true, failedPropExps), `}`);
+    yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, codeFeatures_1.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props, options.vueCompilerOptions.checkUnknownProps, true, failedPropExps), `}`);
     yield `)${utils_1.endOfLine}`;
     yield* generateFailedPropExps(options, ctx, failedPropExps);
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
@@ -225,7 +229,7 @@ function* generateElement(options, ctx, node) {
 }
 function* generateFailedPropExps(options, ctx, failedPropExps) {
     for (const failedExp of failedPropExps) {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, failedExp.node.loc.source, failedExp.node.loc.start.offset, failedExp.prefix, failedExp.suffix);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.all, failedExp.node.loc.source, failedExp.node.loc.start.offset, failedExp.prefix, failedExp.suffix);
         yield utils_1.endOfLine;
     }
 }
@@ -258,11 +262,11 @@ function* generateCanonicalComponentName(tagText, offset, features) {
 function* generateComponentGeneric(ctx) {
     if (ctx.currentInfo.generic) {
         const { content, offset } = ctx.currentInfo.generic;
-        yield* (0, wrapWith_1.wrapWith)(offset, offset + content.length, ctx.codeFeatures.verification, `<`, [
+        yield* (0, wrapWith_1.wrapWith)(offset, offset + content.length, codeFeatures_1.codeFeatures.verification, `<`, [
             content,
             'template',
             offset,
-            ctx.codeFeatures.all,
+            codeFeatures_1.codeFeatures.all,
         ], `>`);
     }
 }
@@ -274,7 +278,7 @@ function* generateElementReference(options, ctx, node) {
             const [content, startOffset] = (0, utils_1.normalizeAttributeValue)(prop.value);
             // navigation support for `const foo = ref()`
             yield `/** @type {typeof __VLS_ctx`;
-            yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, content, startOffset, ctx.codeFeatures.navigation);
+            yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, content, startOffset, codeFeatures_1.codeFeatures.navigation);
             yield `} */${utils_1.endOfLine}`;
             if (utils_1.identifierRegex.test(content) && !options.templateRefNames.has(content)) {
                 ctx.accessExternalVariable(content, startOffset);

package/lib/codegen/template/elementDirectives.js

@@ -30,16 +30,16 @@ function* generateElementDirectives(options, ctx, node) {
             continue;
         }
         ctx.accessExternalVariable((0, shared_1.camelize)('v-' + prop.name), prop.loc.start.offset);
-        yield* (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, `__VLS_asFunctionalDirective(`, ...generateIdentifier(options, ctx, prop), `)(null!, { ...__VLS_directiveBindingRestFields, `, ...generateArg(options, ctx, prop), ...generateModifiers(options, ctx, prop), ...generateValue(options, ctx, prop), ` }, null!, null!)`);
+        yield* (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, codeFeatures_1.codeFeatures.verification, `__VLS_asFunctionalDirective(`, ...generateIdentifier(options, prop), `)(null!, { ...__VLS_directiveBindingRestFields, `, ...generateArg(options, ctx, prop), ...generateModifiers(options, ctx, prop), ...generateValue(options, ctx, prop), ` }, null!, null!)`);
         yield utils_1.endOfLine;
     }
 }
-function* generateIdentifier(options, ctx, prop) {
+function* generateIdentifier(options, prop) {
     const rawName = 'v-' + prop.name;
-    yield* (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + rawName.length, ctx.codeFeatures.verification, `__VLS_directives.`, ...(0, camelized_1.generateCamelized)(rawName, 'template', prop.loc.start.offset, ctx.resolveCodeFeatures({
+    yield* (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + rawName.length, codeFeatures_1.codeFeatures.verification, `__VLS_directives.`, ...(0, camelized_1.generateCamelized)(rawName, 'template', prop.loc.start.offset, {
         ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletion,
         verification: options.vueCompilerOptions.checkUnknownDirectives && !builtInDirectives.has(prop.name),
-    })));
+    }));
 }
 function* generateArg(options, ctx, prop) {
     const { arg } = prop;
@@ -47,13 +47,13 @@ function* generateArg(options, ctx, prop) {
         return;
     }
     const startOffset = arg.loc.start.offset + arg.loc.source.indexOf(arg.content);
-    yield* (0, wrapWith_1.wrapWith)(startOffset, startOffset + arg.content.length, ctx.codeFeatures.verification, `arg`);
+    yield* (0, wrapWith_1.wrapWith)(startOffset, startOffset + arg.content.length, codeFeatures_1.codeFeatures.verification, `arg`);
     yield `: `;
     if (arg.isStatic) {
-        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, ctx.codeFeatures.all);
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, codeFeatures_1.codeFeatures.all);
     }
     else {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, arg.content, startOffset, `(`, `)`);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.all, arg.content, startOffset, `(`, `)`);
     }
     yield `, `;
 }
@@ -64,10 +64,10 @@ function* generateModifiers(options, ctx, prop, propertyName = 'modifiers') {
     }
     const startOffset = modifiers[0].loc.start.offset - 1;
     const endOffset = modifiers.at(-1).loc.end.offset;
-    yield* (0, wrapWith_1.wrapWith)(startOffset, endOffset, ctx.codeFeatures.verification, propertyName);
+    yield* (0, wrapWith_1.wrapWith)(startOffset, endOffset, codeFeatures_1.codeFeatures.verification, propertyName);
     yield `: { `;
     for (const mod of modifiers) {
-        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, mod.content, mod.loc.start.offset, ctx.codeFeatures.withoutHighlightAndNavigation);
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, mod.content, mod.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlight);
         yield `: true, `;
     }
     yield `}, `;
@@ -77,7 +77,7 @@ function* generateValue(options, ctx, prop) {
     if (exp?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         return;
     }
-    yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, ctx.codeFeatures.verification, `value`);
+    yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `value`);
     yield `: `;
     yield* (0, elementProps_1.generatePropExp)(options, ctx, prop, exp);
 }

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

@@ -4,7 +4,7 @@ import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
 export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentOriginalVar: string, componentFunctionalVar: string, componentVNodeVar: string, componentCtxVar: string): Generator<Code>;
-export declare function generateEventArg(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, name: string, start: number, directive?: string, features?: VueCodeInformation): Generator<Code>;
+export declare function generateEventArg(options: TemplateCodegenOptions, name: string, start: number, directive?: string, features?: VueCodeInformation): Generator<Code>;
 export declare function generateEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;
 export declare function generateModelEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;
 export declare function isCompoundExpression(ts: typeof import('typescript'), ast: ts.SourceFile): boolean;

package/lib/codegen/template/elementEvents.js

@@ -49,12 +49,12 @@ function* generateElementEvents(options, ctx, node, componentOriginalVar, compon
             yield `const ${ctx.getInternalVariable()}: __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${emitsVar}, '${propName}', '${emitName}', '${camelizedEmitName}'> = (${utils_1.newLine}`;
             if (prop.name === 'on') {
                 yield `{ `;
-                yield* generateEventArg(options, ctx, source, start, emitPrefix.slice(0, -1), ctx.codeFeatures.navigation);
+                yield* generateEventArg(options, source, start, emitPrefix.slice(0, -1), codeFeatures_1.codeFeatures.navigation);
                 yield `: {} as any } as typeof ${emitsVar},${utils_1.newLine}`;
             }
             yield `{ `;
             if (prop.name === 'on') {
-                yield* generateEventArg(options, ctx, source, start, propPrefix.slice(0, -1));
+                yield* generateEventArg(options, source, start, propPrefix.slice(0, -1));
                 yield `: `;
                 yield* generateEventExpression(options, ctx, prop);
             }
@@ -66,14 +66,14 @@ function* generateElementEvents(options, ctx, node, componentOriginalVar, compon
         }
     }
 }
-function* generateEventArg(options, ctx, name, start, directive = 'on', features) {
-    features ??= ctx.resolveCodeFeatures({
+function* generateEventArg(options, name, start, directive = 'on', features) {
+    features ??= {
         ...codeFeatures_1.codeFeatures.semanticWithoutHighlight,
         ...codeFeatures_1.codeFeatures.navigationWithoutRename,
         ...options.vueCompilerOptions.checkUnknownEvents
             ? codeFeatures_1.codeFeatures.verification
             : codeFeatures_1.codeFeatures.doNotReportTs2353AndTs2561,
-    });
+    };
     if (directive.length) {
         name = (0, shared_1.capitalize)(name);
     }
@@ -88,19 +88,10 @@ function* generateEventArg(options, ctx, name, start, directive = 'on', features
 }
 function* generateEventExpression(options, ctx, prop) {
     if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        let prefix = `(`;
-        let suffix = `)`;
         let isFirstMapping = true;
         const ast = (0, utils_1.createTsAst)(options.ts, ctx.inlineTsAsts, prop.exp.content);
         const isCompound = isCompoundExpression(options.ts, ast);
-        if (isCompound) {
-            ctx.addLocalVariable('$event');
-            yield `(...[$event]) => {${utils_1.newLine}`;
-            yield* ctx.generateConditionGuards();
-            prefix = ``;
-            suffix = ``;
-        }
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', offset => {
+        const interpolation = (0, interpolation_1.generateInterpolation)(options, ctx, 'template', offset => {
             if (isCompound && isFirstMapping) {
                 isFirstMapping = false;
                 ctx.inlayHints.push({
@@ -116,14 +107,21 @@ function* generateEventExpression(options, ctx, prop) {
                     ].join('\n\n'),
                 });
             }
-            return ctx.codeFeatures.all;
-        }, prop.exp.content, prop.exp.loc.start.offset, prefix, suffix);
+            return codeFeatures_1.codeFeatures.all;
+        }, prop.exp.content, prop.exp.loc.start.offset, isCompound ? `` : `(`, isCompound ? `` : `)`);
         if (isCompound) {
-            ctx.removeLocalVariable('$event');
+            yield `(...[$event]) => {${utils_1.newLine}`;
+            ctx.addLocalVariable('$event');
+            yield* ctx.generateConditionGuards();
+            yield* interpolation;
             yield utils_1.endOfLine;
+            ctx.removeLocalVariable('$event');
             yield* ctx.generateAutoImportCompletion();
             yield `}`;
         }
+        else {
+            yield* interpolation;
+        }
     }
     else {
         yield `() => {}`;
@@ -133,7 +131,7 @@ function* generateModelEventExpression(options, ctx, prop) {
     if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         yield `(...[$event]) => {${utils_1.newLine}`;
         yield* ctx.generateConditionGuards();
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.verification, prop.exp.content, prop.exp.loc.start.offset);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.verification, prop.exp.content, prop.exp.loc.start.offset);
         yield ` = $event${utils_1.endOfLine}`;
         yield `}`;
     }

package/lib/codegen/template/elementProps.js

@@ -27,7 +27,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
                 && !prop.arg.loc.source.endsWith(']')) {
                 if (!isComponent) {
                     yield `...{ `;
-                    yield* (0, elementEvents_1.generateEventArg)(options, ctx, prop.arg.loc.source, prop.arg.loc.start.offset);
+                    yield* (0, elementEvents_1.generateEventArg)(options, prop.arg.loc.source, prop.arg.loc.start.offset);
                     yield `: `;
                     yield* (0, elementEvents_1.generateEventExpression)(options, ctx, prop);
                     yield `},`;
@@ -77,13 +77,13 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
             }
             const shouldSpread = propName === 'style' || propName === 'class';
             const shouldCamelize = isComponent && getShouldCamelize(options, prop, propName);
-            const codeInfo = getPropsCodeInfo(ctx, strictPropsCheck);
+            const features = getPropsCodeFeatures(strictPropsCheck);
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const codes = [...(0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(prop.arg
-                    ? (0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg.loc.start.offset, codeInfo, shouldCamelize)
-                    : (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, ctx.codeFeatures.withoutHighlightAndCompletion, propName)), `: `, ...(0, wrapWith_1.wrapWith)(prop.arg?.loc.start.offset ?? prop.loc.start.offset, prop.arg?.loc.end.offset ?? prop.loc.end.offset, ctx.codeFeatures.verification, ...generatePropExp(options, ctx, prop, prop.exp, enableCodeFeatures)))];
+            const codes = [...(0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, codeFeatures_1.codeFeatures.verification, ...(prop.arg
+                    ? (0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg.loc.start.offset, features, shouldCamelize)
+                    : (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion, propName)), `: `, ...(0, wrapWith_1.wrapWith)(prop.arg?.loc.start.offset ?? prop.loc.start.offset, prop.arg?.loc.end.offset ?? prop.loc.end.offset, codeFeatures_1.codeFeatures.verification, ...generatePropExp(options, ctx, prop, prop.exp, enableCodeFeatures)))];
             if (enableCodeFeatures) {
                 yield* codes;
             }
@@ -120,12 +120,12 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
             }
             const shouldSpread = prop.name === 'style' || prop.name === 'class';
             const shouldCamelize = isComponent && getShouldCamelize(options, prop, prop.name);
-            const codeInfo = getPropsCodeInfo(ctx, strictPropsCheck);
+            const features = getPropsCodeFeatures(strictPropsCheck);
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const codes = [...(0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, codeInfo, shouldCamelize), `: `, ...(prop.value
-                    ? generateAttrValue(prop.value, ctx.codeFeatures.withoutNavigation)
+            const codes = [...(0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, codeFeatures_1.codeFeatures.verification, ...(0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, features, shouldCamelize), `: `, ...(prop.value
+                    ? generateAttrValue(prop.value, codeFeatures_1.codeFeatures.withoutNavigation)
                     : [`true`]))];
             if (enableCodeFeatures) {
                 yield* codes;
@@ -148,7 +148,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
                 }
             }
             else {
-                const codes = [...(0, wrapWith_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, `...`, ...generatePropExp(options, ctx, prop, prop.exp, enableCodeFeatures))];
+                const codes = [...(0, wrapWith_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `...`, ...generatePropExp(options, ctx, prop, prop.exp, enableCodeFeatures))];
                 if (enableCodeFeatures) {
                     yield* codes;
                 }
@@ -163,8 +163,8 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
 function* generatePropExp(options, ctx, prop, exp, enableCodeFeatures = true) {
     const isShorthand = prop.arg?.loc.start.offset === prop.exp?.loc.start.offset;
     const features = isShorthand
-        ? ctx.codeFeatures.withoutHighlightAndCompletion
-        : ctx.codeFeatures.all;
+        ? codeFeatures_1.codeFeatures.withoutHighlightAndCompletion
+        : codeFeatures_1.codeFeatures.all;
     if (exp && exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) { // style='z-index: 2' will compile to {'z-index':'2'}
         if (!isShorthand) { // vue 3.4+
             yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, exp.loc.source, exp.loc.start.offset, `(`, `)`);
@@ -220,13 +220,13 @@ function getShouldCamelize(options, prop, propName) {
         && (0, shared_2.hyphenateAttr)(propName) === propName
         && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, picomatch_1.isMatch)(propName, pattern));
 }
-function getPropsCodeInfo(ctx, strictPropsCheck) {
-    return ctx.resolveCodeFeatures({
+function getPropsCodeFeatures(strictPropsCheck) {
+    return {
         ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletion,
         ...strictPropsCheck
             ? codeFeatures_1.codeFeatures.verification
             : codeFeatures_1.codeFeatures.doNotReportTs2353AndTs2561,
-    });
+    };
 }
 function getModelPropName(node, vueCompilerOptions) {
     for (const modelName in vueCompilerOptions.experimentalModelPropName) {

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

@@ -1,7 +1,8 @@
 import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
 import type { Code, Sfc, VueCompilerOptions } from '../../types';
-import { type TemplateCodegenContext } from './context';
+import type { TemplateCodegenContext } from './context';
+export * from './context';
 export interface TemplateCodegenOptions {
     ts: typeof ts;
     compilerOptions: ts.CompilerOptions;
@@ -17,5 +18,5 @@ export interface TemplateCodegenOptions {
     inheritAttrs: boolean;
     selfComponentName?: string;
 }
-export declare function generateTemplate(options: TemplateCodegenOptions): Generator<Code, TemplateCodegenContext>;
+export declare function generateTemplate(options: TemplateCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;
 export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;

package/lib/codegen/template/index.js

@@ -1,17 +1,31 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTemplate = generateTemplate;
 exports.forEachElementNode = forEachElementNode;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("../../utils/shared");
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
-const context_1 = require("./context");
 const objectProperty_1 = require("./objectProperty");
 const styleScopedClasses_1 = require("./styleScopedClasses");
 const templateChild_1 = require("./templateChild");
-function* generateTemplate(options) {
-    const ctx = (0, context_1.createTemplateCodegenContext)(options, options.template.ast);
+__exportStar(require("./context"), exports);
+function* generateTemplate(options, ctx) {
     if (options.slotsAssignName) {
         ctx.addLocalVariable(options.slotsAssignName);
     }
@@ -47,7 +61,6 @@ function* generateTemplate(options) {
         yield `${name}: ${type}${utils_1.endOfLine}`;
     }
     yield `} & { [K in keyof import('${options.vueCompilerOptions.lib}').ComponentPublicInstance]: unknown }${utils_1.endOfLine}`;
-    return ctx;
 }
 function* generateSlots(options, ctx) {
     if (!options.hasDefineSlots) {
@@ -58,10 +71,10 @@ function* generateSlots(options, ctx) {
         for (const slot of ctx.slots) {
             yield `${utils_1.newLine}& { `;
             if (slot.name && slot.offset !== undefined) {
-                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.offset, ctx.codeFeatures.navigation);
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.offset, codeFeatures_1.codeFeatures.navigation);
             }
             else {
-                yield* (0, wrapWith_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], ctx.codeFeatures.navigation, `default`);
+                yield* (0, wrapWith_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], codeFeatures_1.codeFeatures.navigation, `default`);
             }
             yield `?: (props: typeof ${slot.propsVar}) => any }`;
         }
@@ -83,7 +96,7 @@ function* generateInheritedAttrs(options, ctx) {
                 loc.source,
                 'template',
                 loc.start.offset,
-                ctx.codeFeatures.all,
+                codeFeatures_1.codeFeatures.all,
             ];
             yield `,`;
         }
@@ -104,7 +117,7 @@ function* generateTemplateRefs(options, ctx) {
                 yield ` | `;
             }
             yield `{ `;
-            yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, name, offset, ctx.codeFeatures.navigation);
+            yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, name, offset, codeFeatures_1.codeFeatures.navigation);
             yield `: ${typeExp} }`;
         }
         if (refs.length >= 2) {

package/lib/codegen/template/interpolation.js

@@ -4,6 +4,7 @@ exports.generateInterpolation = generateInterpolation;
 const shared_1 = require("@vue/shared");
 const collectBindings_1 = require("../../utils/collectBindings");
 const shared_2 = require("../../utils/shared");
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 // https://github.com/vuejs/core/blob/fb0c3ca519f1fccf52049cd6b8db3a67a669afe9/packages/compiler-core/src/transforms/transformExpression.ts#L47
 const isLiteralWhitelisted = /*@__PURE__*/ (0, shared_1.makeMap)('true,false,null,this');
@@ -35,7 +36,7 @@ function* generateInterpolation(options, ctx, source, data, code, start, prefix
                         source,
                         start + offset,
                         type === 'errorMappingOnly'
-                            ? ctx.codeFeatures.verification
+                            ? codeFeatures_1.codeFeatures.verification
                             : typeof data === 'function'
                                 ? data(start + offset)
                                 : data,

package/lib/codegen/template/slotOutlet.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSlotOutlet = generateSlotOutlet;
 const CompilerDOM = require("@vue/compiler-dom");
+const codeFeatures_1 = require("../codeFeatures");
 const inlayHints_1 = require("../inlayHints");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
@@ -34,7 +35,7 @@ function* generateSlotOutlet(options, ctx, node) {
                     source = source.slice(1, -1);
                     offset++;
                 }
-                codes = (0, propertyAccess_1.generatePropertyAccess)(options, ctx, source, offset, ctx.codeFeatures.navigationAndVerification);
+                codes = (0, propertyAccess_1.generatePropertyAccess)(options, ctx, source, offset, codeFeatures_1.codeFeatures.navigationAndVerification);
             }
             else if (nameProp.type === CompilerDOM.NodeTypes.DIRECTIVE
                 && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -47,13 +48,13 @@ function* generateSlotOutlet(options, ctx, node) {
             else {
                 codes = [`['default']`];
             }
-            yield* (0, wrapWith_1.wrapWith)(nameProp.loc.start.offset, nameProp.loc.end.offset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}`, ...codes);
+            yield* (0, wrapWith_1.wrapWith)(nameProp.loc.start.offset, nameProp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}`, ...codes);
         }
         else {
-            yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, ctx.codeFeatures.verification, `'default'`), `]`);
+            yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `'default'`), `]`);
         }
         yield `)(`;
-        yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, ctx.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true, true), `}`);
+        yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true, true), `}`);
         yield `)${utils_1.endOfLine}`;
     }
     else {
@@ -78,7 +79,7 @@ function* generateSlotOutlet(options, ctx, node) {
             }
             const expVar = ctx.getInternalVariable();
             yield `var ${expVar} = __VLS_tryAsConstant(`;
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset);
             yield `)${utils_1.endOfLine}`;
             ctx.dynamicSlots.push({
                 expVar: ctx.getHoistVariable(expVar),

package/lib/codegen/template/styleScopedClasses.js

@@ -4,6 +4,7 @@ exports.generateStyleScopedClassReferences = generateStyleScopedClassReferences;
 exports.collectStyleScopedClassReferences = collectStyleScopedClassReferences;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("../../utils/shared");
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const escaped_1 = require("../utils/escaped");
 const wrapWith_1 = require("../utils/wrapWith");
@@ -15,13 +16,13 @@ function* generateStyleScopedClassReferences(ctx, withDot = false) {
             '',
             'template',
             offset,
-            ctx.codeFeatures.additionalCompletion,
+            codeFeatures_1.codeFeatures.additionalCompletion,
         ];
         yield `']} */${utils_1.endOfLine}`;
     }
     for (const { source, className, offset } of ctx.scopedClasses) {
         yield `/** @type {__VLS_StyleScopedClasses[`;
-        yield* (0, wrapWith_1.wrapWith)(offset - (withDot ? 1 : 0), offset + className.length, source, ctx.codeFeatures.navigation, `'`, ...(0, escaped_1.generateEscaped)(className, source, offset, ctx.codeFeatures.navigationAndAdditionalCompletion, classNameEscapeRegex), `'`);
+        yield* (0, wrapWith_1.wrapWith)(offset - (withDot ? 1 : 0), offset + className.length, source, codeFeatures_1.codeFeatures.navigation, `'`, ...(0, escaped_1.generateEscaped)(className, source, offset, codeFeatures_1.codeFeatures.navigationAndAdditionalCompletion, classNameEscapeRegex), `'`);
         yield `]} */${utils_1.endOfLine}`;
     }
 }

package/lib/codegen/template/templateChild.js

@@ -5,6 +5,7 @@ exports.getVForNode = getVForNode;
 exports.parseInterpolationNode = parseInterpolationNode;
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("../../utils/shared");
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const element_1 = require("./element");
 const elementChildren_1 = require("./elementChildren");
@@ -83,7 +84,7 @@ function* generateTemplateChild(options, ctx, node, enterNode = true) {
     else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
         // {{ ... }}
         const [content, start] = parseInterpolationNode(node, options.template.content);
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, content, start, `(`, `)${utils_1.endOfLine}`);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.all, content, start, `(`, `)${utils_1.endOfLine}`);
     }
     else if (node.type === CompilerDOM.NodeTypes.IF) {
         // v-if / v-else-if / v-else

package/lib/codegen/template/vFor.js

@@ -4,6 +4,7 @@ exports.generateVFor = generateVFor;
 exports.parseVForNode = parseVForNode;
 const CompilerDOM = require("@vue/compiler-dom");
 const collectBindings_1 = require("../../utils/collectBindings");
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const elementChildren_1 = require("./elementChildren");
 const interpolation_1 = require("./interpolation");
@@ -19,13 +20,13 @@ function* generateVFor(options, ctx, node) {
             leftExpressionText,
             'template',
             leftExpressionRange.start,
-            ctx.codeFeatures.all,
+            codeFeatures_1.codeFeatures.all,
         ];
     }
     yield `] of `;
     if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         yield `__VLS_getVForSourceType(`;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, source.content, source.loc.start.offset, `(`, `)`);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.all, source.content, source.loc.start.offset, `(`, `)`);
         yield `!)`; // #3102
     }
     else {
@@ -47,7 +48,7 @@ function* generateVFor(options, ctx, node) {
             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, 'template', ctx.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, `(`, `)`);
+                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, `(`, `)`);
                     yield utils_1.endOfLine;
                 }
             }

package/lib/codegen/template/vIf.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateVIf = generateVIf;
 const CompilerDOM = require("@vue/compiler-dom");
 const muggle_string_1 = require("muggle-string");
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const elementChildren_1 = require("./elementChildren");
 const interpolation_1 = require("./interpolation");
@@ -21,7 +22,7 @@ function* generateVIf(options, ctx, node) {
         }
         let addedBlockCondition = false;
         if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-            const codes = [...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, `(`, `)`)];
+            const codes = [...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', codeFeatures_1.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, `(`, `)`)];
             yield* codes;
             ctx.blockConditions.push((0, muggle_string_1.toString)(codes));
             addedBlockCondition = true;

package/lib/codegen/template/vSlot.js

@@ -4,6 +4,7 @@ exports.generateVSlot = generateVSlot;
 const CompilerDOM = require("@vue/compiler-dom");
 const collectBindings_1 = require("../../utils/collectBindings");
 const shared_1 = require("../../utils/shared");
+const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
 const elementChildren_1 = require("./elementChildren");
@@ -22,22 +23,22 @@ function* generateVSlot(options, ctx, node, slotDir) {
         yield `const { `;
         if (slotDir) {
             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, false, true);
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? codeFeatures_1.codeFeatures.withoutHighlight : codeFeatures_1.codeFeatures.all, false, true);
             }
             else {
-                yield* (0, wrapWith_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+                yield* (0, wrapWith_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), codeFeatures_1.codeFeatures.withoutHighlightAndCompletion, `default`);
             }
         }
         else {
             // #932: reference for implicit default slot
-            yield* (0, wrapWith_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.navigation, `default`);
+            yield* (0, wrapWith_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, codeFeatures_1.codeFeatures.navigation, `default`);
         }
         yield `: ${slotVar} } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
     }
     if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         const slotAst = (0, utils_1.createTsAst)(options.ts, ctx.inlineTsAsts, `(${slotDir.exp.content}) => {}`);
         slotBlockVars.push(...(0, collectBindings_1.collectBindingNames)(options.ts, slotAst, slotAst));
-        yield* generateSlotParameters(options, ctx, slotAst, slotDir.exp, slotVar);
+        yield* generateSlotParameters(options, slotAst, slotDir.exp, slotVar);
     }
     for (const varName of slotBlockVars) {
         ctx.addLocalVariable(varName);
@@ -61,14 +62,14 @@ function* generateVSlot(options, ctx, node, slotDir) {
                     : slotDir.loc.source.startsWith('v-slot:')
                         ? 'v-slot:'.length
                         : 0),
-                ctx.codeFeatures.completion,
+                codeFeatures_1.codeFeatures.completion,
             ];
             yield `'/* empty slot name completion */]${utils_1.endOfLine}`;
         }
         yield `}${utils_1.newLine}`;
     }
 }
-function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
+function* generateSlotParameters(options, ast, exp, slotVar) {
     const { ts } = options;
     const statement = ast.statements[0];
     if (!ts.isExpressionStatement(statement) || !ts.isArrowFunction(statement.expression)) {
@@ -102,7 +103,7 @@ function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
     yield `] = __VLS_getSlotParameters(${slotVar}!`;
     if (types.some(t => t)) {
         yield `, `;
-        yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, ctx.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_: `, type, `, `] : `_, `), `) => [] as any`);
+        yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_: `, type, `, `] : `_, `), `) => [] as any`);
     }
     yield `)${utils_1.endOfLine}`;
     function chunk(start, end) {
@@ -110,7 +111,7 @@ function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
             ast.text.slice(start, end),
             'template',
             startOffset + start,
-            ctx.codeFeatures.all,
+            codeFeatures_1.codeFeatures.all,
         ];
     }
 }

package/lib/parsers/utils.d.ts

@@ -0,0 +1,12 @@
+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 getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): {
+    start: number;
+    end: number;
+} | undefined;

package/lib/parsers/utils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBindingRanges = parseBindingRanges;
+exports.getClosestMultiLineCommentRange = getClosestMultiLineCommentRange;
+const collectBindings_1 = require("../utils/collectBindings");
+const shared_1 = require("../utils/shared");
+function parseBindingRanges(ts, ast) {
+    const bindings = [];
+    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 })));
+            }
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                bindings.push({
+                    range: _getStartEnd(node.name),
+                });
+            }
+        }
+        else if (ts.isClassDeclaration(node)) {
+            if (node.name) {
+                bindings.push({
+                    range: _getStartEnd(node.name),
+                });
+            }
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            bindings.push({
+                range: _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 (namedBindings) {
+                    if (ts.isNamedImports(namedBindings)) {
+                        for (const element of namedBindings.elements) {
+                            if (element.isTypeOnly) {
+                                continue;
+                            }
+                            bindings.push({
+                                range: _getStartEnd(element.name),
+                                moduleName,
+                                isDefaultImport: element.propertyName?.text === 'default',
+                            });
+                        }
+                    }
+                    else {
+                        bindings.push({
+                            range: _getStartEnd(namedBindings.name),
+                            moduleName,
+                            isNamespace: true,
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return bindings;
+    function _getStartEnd(node) {
+        return (0, shared_1.getStartEnd)(ts, node, ast);
+    }
+    function _getNodeText(node) {
+        return (0, shared_1.getNodeText)(ts, node, ast);
+    }
+}
+function getClosestMultiLineCommentRange(ts, node, parents, ast) {
+    for (let i = parents.length - 1; i >= 0; i--) {
+        if (ts.isStatement(node)) {
+            break;
+        }
+        node = parents[i];
+    }
+    const comment = ts.getLeadingCommentRanges(ast.text, node.pos)
+        ?.reverse()
+        .find(range => range.kind === 3);
+    if (comment) {
+        return {
+            start: comment.pos,
+            end: comment.end,
+        };
+    }
+}
+//# sourceMappingURL=utils.js.map

package/lib/plugins/file-vue.js

@@ -16,7 +16,22 @@ const plugin = ({ vueCompilerOptions }) => {
             if (languageId !== 'vue') {
                 return;
             }
-            return (0, parseSfc_1.parse)(content);
+            const sfc = (0, parseSfc_1.parse)(content);
+            for (const error of sfc.errors) {
+                // Handle 'Element is missing end tag.' error, see #4893
+                if ('code' in error && error.code === 24 && sfc.descriptor.template
+                    && error.loc?.start.line === sfc.descriptor.template.loc.start.line) {
+                    const template = sfc.descriptor.template;
+                    const templateText = template.content;
+                    const endTagOffset = templateText.lastIndexOf('<');
+                    const endTagText = templateText.slice(endTagOffset).trimEnd();
+                    if ('</template>'.startsWith(endTagText)) {
+                        sfc.descriptor.template.loc.end.offset = template.loc.start.offset + endTagOffset;
+                        template.content = templateText.slice(0, endTagOffset);
+                    }
+                }
+            }
+            return sfc;
         },
         updateSFC(sfc, change) {
             const blocks = [

package/lib/plugins/vue-style-css.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const plugin = () => {
     return {
-        version: 2.1,
+        version: 2.2,
         compileSFCStyle(_lang, style) {
             return {
                 imports: [...parseCssImports(style)],

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

@@ -149,28 +149,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
                 offset: number;
             };
         };
-        codeFeatures: {
-            all: 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;
-            semanticWithoutHighlight: import("../types").VueCodeInformation;
-            withoutHighlight: import("../types").VueCodeInformation;
-            withoutHighlightAndNavigation: import("../types").VueCodeInformation;
-            withoutHighlightAndCompletion: import("../types").VueCodeInformation;
-            withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
-            withoutSemantic: import("../types").VueCodeInformation;
-            doNotReportTs2339AndTs2551: import("../types").VueCodeInformation;
-            doNotReportTs2353AndTs2561: import("../types").VueCodeInformation;
-            doNotReportTs6133: import("../types").VueCodeInformation;
-        };
         resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
         inlineTsAsts: Map<string, import("typescript").SourceFile> | undefined;
         inVFor: boolean;

package/lib/plugins/vue-tsx.js

@@ -144,8 +144,7 @@ function createTsx(fileName, sfc, ctx) {
         if (getResolvedOptions().skipTemplateCodegen || !sfc.template) {
             return;
         }
-        const codes = [];
-        const codegen = (0, template_1.generateTemplate)({
+        const options = {
             ts,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: getResolvedOptions(),
@@ -159,21 +158,23 @@ function createTsx(fileName, sfc, ctx) {
             propsAssignName: getSetupPropsAssignName(),
             inheritAttrs: getSetupInheritAttrs(),
             selfComponentName: getComponentSelfName(),
-        });
-        let current = codegen.next();
-        while (!current.done) {
-            const code = current.value;
+        };
+        const context = (0, template_1.createTemplateCodegenContext)(options, sfc.template.ast);
+        const codegen = (0, template_1.generateTemplate)(options, context);
+        const codes = [];
+        for (const code of codegen) {
+            if (typeof code === 'object') {
+                code[3] = context.resolveCodeFeatures(code[3]);
+            }
             codes.push(code);
-            current = codegen.next();
         }
         return {
-            ...current.value,
+            ...context,
             codes,
         };
     });
     const getGeneratedScript = (0, alien_signals_1.computed)(() => {
-        const codes = [];
-        const codegen = (0, script_1.generateScript)({
+        const options = {
             ts,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: getResolvedOptions(),
@@ -185,16 +186,12 @@ function createTsx(fileName, sfc, ctx) {
             templateCodegen: getGeneratedTemplate(),
             destructuredPropNames: getSetupDestructuredPropNames(),
             templateRefNames: getSetupTemplateRefNames(),
-        });
-        let current = codegen.next();
-        while (!current.done) {
-            const code = current.value;
-            codes.push(code);
-            current = codegen.next();
-        }
+        };
+        const context = (0, script_1.createScriptCodegenContext)(options);
+        const codegen = (0, script_1.generateScript)(options, context);
         return {
-            ...current.value,
-            codes,
+            ...context,
+            codes: [...codegen],
         };
     });
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.4",
+	"version": "3.0.5",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -13,7 +13,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.4.20",
+		"@volar/language-core": "2.4.22",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/compiler-vue2": "^2.7.16",
 		"@vue/shared": "^3.5.0",
@@ -26,7 +26,7 @@
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1",
 		"@types/picomatch": "^4.0.0",
-		"@volar/typescript": "2.4.20",
+		"@volar/typescript": "2.4.22",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
 	"peerDependencies": {
@@ -37,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "148d386f9779c2de64cdcbd35310e03b36943b05"
+	"gitHead": "036b6b1882179d35586e16f2a5cba5150e5d18e6"
 }