@vue/language-core 3.0.4 → 3.0.6

package/lib/codegen/codeFeatures.d.ts

@@ -30,10 +30,6 @@ declare const raw: {
             shouldRename: () => false;
         };
     };
-    navigationAndCompletion: {
-        navigation: true;
-        completion: true;
-    };
     navigationAndAdditionalCompletion: {
         navigation: true;
         completion: {
@@ -62,13 +58,6 @@ declare const raw: {
         navigation: true;
         completion: true;
     };
-    withoutHighlightAndNavigation: {
-        semantic: {
-            shouldHighlight: () => false;
-        };
-        verification: true;
-        completion: true;
-    };
     withoutHighlightAndCompletion: {
         semantic: {
             shouldHighlight: () => false;
@@ -76,12 +65,6 @@ declare const raw: {
         verification: true;
         navigation: true;
     };
-    withoutHighlightAndCompletionAndNavigation: {
-        semantic: {
-            shouldHighlight: () => false;
-        };
-        verification: true;
-    };
     withoutSemantic: {
         verification: true;
         navigation: true;

package/lib/codegen/codeFeatures.js

@@ -28,10 +28,6 @@ const raw = {
     navigationWithoutRename: {
         navigation: { shouldRename: () => false },
     },
-    navigationAndCompletion: {
-        navigation: true,
-        completion: true,
-    },
     navigationAndAdditionalCompletion: {
         navigation: true,
         completion: { isAdditional: true },
@@ -54,20 +50,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/component.d.ts

@@ -3,6 +3,6 @@ import type { Code, Sfc } from '../../types';
 import type { ScriptCodegenContext } from './context';
 import type { ScriptCodegenOptions } from './index';
 export declare function generateComponent(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
-export declare function generateComponentSetupReturns(scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
+export declare function generateComponentSetupReturns(scriptSetupRanges: ScriptSetupRanges): Generator<string>;
 export declare function generateEmitsOption(options: ScriptCodegenOptions, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
 export declare function generatePropsOption(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges, hasEmitsOption: boolean, inheritAttrs: boolean): Generator<Code>;

package/lib/codegen/script/component.js

@@ -17,23 +17,18 @@ function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
     else {
         yield `(await import('${options.vueCompilerOptions.lib}')).defineComponent({${utils_1.newLine}`;
     }
-    yield `setup() {${utils_1.newLine}`;
     const returns = [];
     if (ctx.bypassDefineComponent) {
-        yield* `const __VLS_returns = {${utils_1.newLine}`;
-        yield* generateComponentSetupReturns(scriptSetupRanges);
-        yield `}${utils_1.endOfLine}`;
-        returns.push(`typeof __VLS_returns`);
+        returns.push(...generateComponentSetupReturns(scriptSetupRanges));
     }
     if (scriptSetupRanges.defineExpose) {
-        returns.push(`typeof __VLS_exposed`);
+        returns.push(`__VLS_exposed`);
     }
     if (returns.length) {
-        yield `return {} as `;
-        yield* (0, merge_1.generateIntersectMerge)(returns);
-        yield utils_1.endOfLine;
+        yield `setup: () => (`;
+        yield* (0, merge_1.generateSpreadMerge)(returns);
+        yield `),${utils_1.newLine}`;
     }
-    yield `},${utils_1.newLine}`;
     if (!ctx.bypassDefineComponent) {
         const emitOptionCodes = [...generateEmitsOption(options, scriptSetupRanges)];
         yield* emitOptionCodes;
@@ -58,13 +53,14 @@ function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
 function* generateComponentSetupReturns(scriptSetupRanges) {
     // fill $props
     if (scriptSetupRanges.defineProps) {
+        const name = scriptSetupRanges.defineProps.name ?? `__VLS_props`;
         // NOTE: defineProps is inaccurate for $props
-        yield `$props: __VLS_makeOptional(${scriptSetupRanges.defineProps.name ?? `__VLS_props`}),${utils_1.newLine}`;
-        yield `...${scriptSetupRanges.defineProps.name ?? `__VLS_props`},${utils_1.newLine}`;
+        yield name;
+        yield `{} as { $props: Partial<typeof ${name}> }`;
     }
     // fill $emit
     if (scriptSetupRanges.defineEmits) {
-        yield `$emit: ${scriptSetupRanges.defineEmits.name ?? '__VLS_emit'},${utils_1.newLine}`;
+        yield `{} as { $emit: typeof ${scriptSetupRanges.defineEmits.name ?? `__VLS_emit`} }`;
     }
 }
 function* generateEmitsOption(options, scriptSetupRanges) {
@@ -99,7 +95,7 @@ function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasE
     const getOptionCodes = [];
     const typeOptionCodes = [];
     if (inheritAttrs && options.templateCodegen?.inheritedAttrVars.size) {
-        let attrsType = `Partial<__VLS_InheritedAttrs>`;
+        let attrsType = `__VLS_InheritedAttrs`;
         if (hasEmitsOption) {
             attrsType = `Omit<${attrsType}, \`on\${string}\`>`;
         }

package/lib/codegen/script/componentSelf.js

@@ -1,41 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateComponentSelf = generateComponentSelf;
+const shared_1 = require("@vue/shared");
 const path = require("path-browserify");
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const component_1 = require("./component");
-const template_1 = require("./template");
 function* generateComponentSelf(options, ctx, templateCodegenCtx) {
     if (options.sfc.scriptSetup && options.scriptSetupRanges) {
         yield `const __VLS_self = (await import('${options.vueCompilerOptions.lib}')).defineComponent({${utils_1.newLine}`;
-        yield `setup() {${utils_1.newLine}`;
-        yield `return {${utils_1.newLine}`;
+        yield `setup: () => ({${utils_1.newLine}`;
         if (ctx.bypassDefineComponent) {
-            yield* (0, component_1.generateComponentSetupReturns)(options.scriptSetupRanges);
+            for (const code of (0, component_1.generateComponentSetupReturns)(options.scriptSetupRanges)) {
+                yield `...${code},${utils_1.newLine}`;
+            }
         }
         // bindings
-        const templateUsageVars = (0, template_1.getTemplateUsageVars)(options, ctx);
-        for (const [content, bindings] of [
-            [options.sfc.scriptSetup.content, options.scriptSetupRanges.bindings],
-            options.sfc.script && options.scriptRanges
-                ? [options.sfc.script.content, options.scriptRanges.bindings]
-                : ['', []],
-        ]) {
-            for (const { range } of bindings) {
-                const varName = content.slice(range.start, range.end);
-                if (!templateUsageVars.has(varName) && !templateCodegenCtx.accessExternalVariables.has(varName)) {
-                    continue;
-                }
-                const token = Symbol(varName.length);
-                yield ['', undefined, 0, { __linkedToken: token }];
-                yield `${varName}: ${varName} as typeof `;
-                yield ['', undefined, 0, { __linkedToken: token }];
-                yield `${varName},${utils_1.newLine}`;
+        const templateUsageVars = new Set([
+            ...options.sfc.template?.ast?.components.flatMap(c => [(0, shared_1.camelize)(c), (0, shared_1.capitalize)((0, shared_1.camelize)(c))]) ?? [],
+            ...options.templateCodegen?.accessExternalVariables.keys() ?? [],
+            ...templateCodegenCtx.accessExternalVariables.keys(),
+        ]);
+        for (const varName of ctx.bindingNames) {
+            if (!templateUsageVars.has(varName)) {
+                continue;
             }
+            const token = Symbol(varName.length);
+            yield ['', undefined, 0, { __linkedToken: token }];
+            yield `${varName}: ${varName} as typeof `;
+            yield ['', undefined, 0, { __linkedToken: token }];
+            yield `${varName},${utils_1.newLine}`;
         }
-        yield `}${utils_1.endOfLine}`; // return {
-        yield `},${utils_1.newLine}`; // setup() {
+        yield `}),${utils_1.newLine}`;
         if (options.sfc.scriptSetup && options.scriptSetupRanges && !ctx.bypassDefineComponent) {
             const emitOptionCodes = [...(0, component_1.generateEmitsOption)(options, options.scriptSetupRanges)];
             yield* emitOptionCodes;

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

@@ -54,7 +54,7 @@ function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
             emitTypes.push(`typeof __VLS_modelEmit`);
         }
         yield `return {} as {${utils_1.newLine}`
-            + `	props: ${ctx.localTypes.PrettifyLocal}<__VLS_OwnProps & __VLS_PublicProps & Partial<__VLS_InheritedAttrs>> & __VLS_BuiltInPublicProps,${utils_1.newLine}`
+            + `	props: ${ctx.localTypes.PrettifyLocal}<__VLS_OwnProps & __VLS_PublicProps & __VLS_InheritedAttrs> & __VLS_BuiltInPublicProps,${utils_1.newLine}`
             + `	expose(exposed: import('${options.vueCompilerOptions.lib}').ShallowUnwrapRef<${scriptSetupRanges.defineExpose ? 'typeof __VLS_exposed' : '{}'}>): void,${utils_1.newLine}`
             + `	attrs: any,${utils_1.newLine}`
             + `	slots: __VLS_Slots,${utils_1.newLine}`
@@ -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/script/template.d.ts

@@ -4,4 +4,3 @@ import type { ScriptCodegenContext } from './context';
 import type { ScriptCodegenOptions } from './index';
 export declare function generateTemplate(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code, TemplateCodegenContext>;
 export declare function generateTemplateDirectives(options: ScriptCodegenOptions): Generator<Code>;
-export declare function getTemplateUsageVars(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Set<string>;

package/lib/codegen/script/template.js

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTemplate = generateTemplate;
 exports.generateTemplateDirectives = generateTemplateDirectives;
-exports.getTemplateUsageVars = getTemplateUsageVars;
-const shared_1 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const modules_1 = require("../style/modules");
 const scopedClasses_1 = require("../style/scopedClasses");
@@ -45,18 +43,11 @@ function* generateTemplateComponents(options) {
     if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {
         const { componentsOption } = options.scriptRanges.exportDefault;
         yield `const __VLS_componentsOption = `;
-        yield [
-            options.sfc.script.content.slice(componentsOption.start, componentsOption.end),
-            'script',
-            componentsOption.start,
-            codeFeatures_1.codeFeatures.navigation,
-        ];
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, componentsOption.start, componentsOption.end, codeFeatures_1.codeFeatures.navigation);
         yield utils_1.endOfLine;
         types.push(`typeof __VLS_componentsOption`);
     }
-    yield `type __VLS_LocalComponents =`;
-    yield* (0, merge_1.generateIntersectMerge)(types);
-    yield utils_1.endOfLine;
+    yield `type __VLS_LocalComponents = ${types.join(` & `)}${utils_1.endOfLine}`;
     yield `let __VLS_components!: __VLS_LocalComponents & __VLS_GlobalComponents${utils_1.endOfLine}`;
 }
 function* generateTemplateDirectives(options) {
@@ -64,18 +55,11 @@ function* generateTemplateDirectives(options) {
     if (options.sfc.script && options.scriptRanges?.exportDefault?.directivesOption) {
         const { directivesOption } = options.scriptRanges.exportDefault;
         yield `const __VLS_directivesOption = `;
-        yield [
-            options.sfc.script.content.slice(directivesOption.start, directivesOption.end),
-            'script',
-            directivesOption.start,
-            codeFeatures_1.codeFeatures.navigation,
-        ];
+        yield (0, utils_1.generateSfcBlockSection)(options.sfc.script, directivesOption.start, directivesOption.end, codeFeatures_1.codeFeatures.navigation);
         yield utils_1.endOfLine;
         types.push(`__VLS_ResolveDirectives<typeof __VLS_directivesOption>`);
     }
-    yield `type __VLS_LocalDirectives =`;
-    yield* (0, merge_1.generateIntersectMerge)(types);
-    yield utils_1.endOfLine;
+    yield `type __VLS_LocalDirectives = ${types.join(` & `)}${utils_1.endOfLine}`;
     yield `let __VLS_directives!: __VLS_LocalDirectives & __VLS_GlobalDirectives${utils_1.endOfLine}`;
 }
 function* generateTemplateBody(options, templateCodegenCtx) {
@@ -101,32 +85,11 @@ function* generateCssVars(options, ctx) {
     }
     yield `// CSS variable injection ${utils_1.newLine}`;
     for (const style of options.sfc.styles) {
-        for (const cssBind of style.cssVars) {
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, style.name, codeFeatures_1.codeFeatures.all, cssBind.text, cssBind.offset);
+        for (const binding of style.bindings) {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, style.name, codeFeatures_1.codeFeatures.all, binding.text, binding.offset);
             yield utils_1.endOfLine;
         }
     }
     yield `// CSS variable injection end ${utils_1.newLine}`;
 }
-function getTemplateUsageVars(options, ctx) {
-    const usageVars = new Set();
-    const components = new Set(options.sfc.template?.ast?.components);
-    if (options.templateCodegen) {
-        // fix import components unused report
-        for (const varName of ctx.bindingNames) {
-            if (components.has(varName) || components.has((0, shared_1.hyphenateTag)(varName))) {
-                usageVars.add(varName);
-            }
-        }
-        for (const component of components) {
-            if (component.includes('.')) {
-                usageVars.add(component.split('.')[0]);
-            }
-        }
-        for (const [varName] of options.templateCodegen.accessExternalVariables) {
-            usageVars.add(varName);
-        }
-    }
-    return usageVars;
-}
 //# sourceMappingURL=template.js.map

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

@@ -20,13 +20,7 @@ const styleScopedClasses_1 = require("./styleScopedClasses");
 const vSlot_1 = require("./vSlot");
 const colonReg = /:/g;
 function* generateComponent(options, ctx, node) {
-    const tagOffsets = [node.loc.start.offset + options.template.content.slice(node.loc.start.offset).indexOf(node.tag)];
-    if (!node.isSelfClosing && options.template.lang === 'html') {
-        const endTagOffset = node.loc.start.offset + node.loc.source.lastIndexOf(node.tag);
-        if (endTagOffset > tagOffsets[0]) {
-            tagOffsets.push(endTagOffset);
-        }
-    }
+    const tagOffsets = (0, shared_2.getElementTagOffsets)(node, options.template);
     const failedPropExps = [];
     const possibleOriginalNames = getPossibleOriginalComponentNames(node.tag, true);
     const matchImportName = possibleOriginalNames.find(name => options.scriptSetupImportComponentNames.has(name));
@@ -76,12 +70,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 +83,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 +104,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 +139,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);
@@ -186,20 +180,16 @@ function* generateComponent(options, ctx, node) {
     }
 }
 function* generateElement(options, ctx, node) {
-    const startTagOffset = node.loc.start.offset
-        + options.template.content.slice(node.loc.start.offset).indexOf(node.tag);
-    const endTagOffset = !node.isSelfClosing && options.template.lang === 'html'
-        ? node.loc.start.offset + node.loc.source.lastIndexOf(node.tag)
-        : undefined;
+    const [startTagOffset, endTagOffset] = (0, shared_2.getElementTagOffsets)(node, options.template);
     const failedPropExps = [];
     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, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
     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, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
     }
     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 +215,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 +248,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 +264,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;