q9

node_modules/@vue/language-core/lib/codegen/common.d.ts

@@ -0,0 +1,12 @@
+import type * as ts from 'typescript';
+import type { Code, SfcBlock, VueCodeInformation } from '../types';
+export declare const newLine = "\n";
+export declare const endOfLine = ";\n";
+export declare const combineLastMapping: VueCodeInformation;
+export declare const variableNameRegex: RegExp;
+export declare function conditionWrapWith(condition: boolean, startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
+export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
+export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, results?: string[]): string[];
+export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: [id: ts.Identifier, isRest: boolean][], isRest?: boolean): [id: ts.Identifier, isRest: boolean][];
+export declare function createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
+export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;

node_modules/@vue/language-core/lib/codegen/common.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
+exports.conditionWrapWith = conditionWrapWith;
+exports.wrapWith = wrapWith;
+exports.collectVars = collectVars;
+exports.collectIdentifiers = collectIdentifiers;
+exports.createTsAst = createTsAst;
+exports.generateSfcBlockSection = generateSfcBlockSection;
+const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
+exports.newLine = '\n';
+exports.endOfLine = `;${exports.newLine}`;
+exports.combineLastMapping = { __combineLastMapping: true };
+exports.variableNameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+function* conditionWrapWith(condition, startOffset, endOffset, features, ...wrapCodes) {
+    if (condition) {
+        yield* wrapWith(startOffset, endOffset, features, ...wrapCodes);
+    }
+    else {
+        for (const wrapCode of wrapCodes) {
+            yield wrapCode;
+        }
+    }
+}
+function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
+    yield ['', 'template', startOffset, features];
+    let offset = 1;
+    for (const wrapCode of wrapCodes) {
+        if (typeof wrapCode !== 'string') {
+            offset++;
+        }
+        yield wrapCode;
+    }
+    yield ['', 'template', endOffset, { __combineOffsetMapping: offset }];
+}
+function collectVars(ts, node, ast, results = []) {
+    const identifiers = collectIdentifiers(ts, node, []);
+    for (const [id] of identifiers) {
+        results.push((0, scriptSetupRanges_1.getNodeText)(ts, id, ast));
+    }
+    return results;
+}
+function collectIdentifiers(ts, node, results = [], isRest = false) {
+    if (ts.isIdentifier(node)) {
+        results.push([node, isRest]);
+    }
+    else if (ts.isObjectBindingPattern(node)) {
+        for (const el of node.elements) {
+            collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
+        }
+    }
+    else if (ts.isArrayBindingPattern(node)) {
+        for (const el of node.elements) {
+            if (ts.isBindingElement(el)) {
+                collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
+            }
+        }
+    }
+    else {
+        ts.forEachChild(node, node => collectIdentifiers(ts, node, results, false));
+    }
+    return results;
+}
+function createTsAst(ts, astHolder, text) {
+    if (astHolder.__volar_ast_text !== text) {
+        astHolder.__volar_ast_text = text;
+        astHolder.__volar_ast = ts.createSourceFile('/a.ts', text, 99);
+    }
+    return astHolder.__volar_ast;
+}
+function generateSfcBlockSection(block, start, end, features) {
+    return [
+        block.content.substring(start, end),
+        block.name,
+        start,
+        features,
+    ];
+}
+//# sourceMappingURL=common.js.map

node_modules/@vue/language-core/lib/codegen/globalTypes.d.ts

@@ -0,0 +1 @@
+export declare function generateGlobalTypes(lib: string, target: number, strictTemplates: boolean): string;

node_modules/@vue/language-core/lib/codegen/globalTypes.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGlobalTypes = generateGlobalTypes;
+const shared_1 = require("../utils/shared");
+function generateGlobalTypes(lib, target, strictTemplates) {
+    const fnPropsType = `(K extends { $props: infer Props } ? Props : any)${strictTemplates ? '' : ' & Record<string, unknown>'}`;
+    let text = ``;
+    if (target < 3.5) {
+        text += `
+; declare module '${lib}' {
+	export interface GlobalComponents { }
+	export interface GlobalDirectives { }
+}`;
+    }
+    text += `
+; declare global {
+	const __VLS_intrinsicElements: __VLS_IntrinsicElements;
+	const __VLS_directiveBindingRestFields: { instance: null, oldValue: null, modifiers: any, dir: any };
+	const __VLS_unref: typeof import('${lib}').unref;
+
+	const __VLS_nativeElements = {
+		...{} as SVGElementTagNameMap,
+		...{} as HTMLElementTagNameMap,
+	};
+
+	type __VLS_IntrinsicElements = ${(target >= 3.3
+        ? `import('${lib}/jsx-runtime').JSX.IntrinsicElements;`
+        : `globalThis.JSX.IntrinsicElements;`)}
+	type __VLS_Element = ${(target >= 3.3
+        ? `import('${lib}/jsx-runtime').JSX.Element;`
+        : `globalThis.JSX.Element;`)}
+	type __VLS_GlobalComponents = ${(target >= 3.5
+        ? `import('${lib}').GlobalComponents;`
+        : `import('${lib}').GlobalComponents & Pick<typeof import('${lib}'), 'Transition' | 'TransitionGroup' | 'KeepAlive' | 'Suspense' | 'Teleport'>;`)}
+	type __VLS_GlobalDirectives = import('${lib}').GlobalDirectives;
+	type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
+	type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
+	type __VLS_unknownDirective = (arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown) => void;
+	type __VLS_WithComponent<N0 extends string, LocalComponents, N1 extends string, N2 extends string, N3 extends string> =
+		N1 extends keyof LocalComponents ? N1 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N1] } :
+		N2 extends keyof LocalComponents ? N2 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N2] } :
+		N3 extends keyof LocalComponents ? N3 extends N0 ? Pick<LocalComponents, N0 extends keyof LocalComponents ? N0 : never> : { [K in N0]: LocalComponents[N3] } :
+		N1 extends keyof __VLS_GlobalComponents ? N1 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N1] } :
+		N2 extends keyof __VLS_GlobalComponents ? N2 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N2] } :
+		N3 extends keyof __VLS_GlobalComponents ? N3 extends N0 ? Pick<__VLS_GlobalComponents, N0 extends keyof __VLS_GlobalComponents ? N0 : never> : { [K in N0]: __VLS_GlobalComponents[N3] } :
+		${strictTemplates ? '{}' : '{ [K in N0]: unknown }'}
+	type __VLS_FunctionalComponentProps<T, K> =
+		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: { props?: infer P } } ? NonNullable<P> : never
+		: T extends (props: infer P, ...args: any) => any ? P :
+		{};
+	type __VLS_IsFunction<T, K> = K extends keyof T
+		? __VLS_IsAny<T[K]> extends false
+		? unknown extends T[K]
+		? false
+		: true
+		: false
+		: false;
+	// fix https://github.com/vuejs/language-tools/issues/926
+	type __VLS_UnionToIntersection<U> = (U extends unknown ? (arg: U) => unknown : never) extends ((arg: infer P) => unknown) ? P : never;
+	type __VLS_OverloadUnionInner<T, U = unknown> = U & T extends (...args: infer A) => infer R
+		? U extends T
+		? never
+		: __VLS_OverloadUnionInner<T, Pick<T, keyof T> & U & ((...args: A) => R)> | ((...args: A) => R)
+		: never;
+	type __VLS_OverloadUnion<T> = Exclude<
+		__VLS_OverloadUnionInner<(() => never) & T>,
+		T extends () => never ? never : () => never
+	>;
+	type __VLS_ConstructorOverloads<T> = __VLS_OverloadUnion<T> extends infer F
+		? F extends (event: infer E, ...args: infer A) => any
+		? { [K in E & string]: (...args: A) => void; }
+		: never
+		: never;
+	type __VLS_NormalizeEmits<T> = __VLS_PrettifyGlobal<
+		__VLS_UnionToIntersection<
+			__VLS_ConstructorOverloads<T> & {
+				[K in keyof T]: T[K] extends any[] ? { (...args: T[K]): void } : never
+			}
+		>
+	>;
+	type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
+	type __VLS_PickFunctionalComponentCtx<T, K> = NonNullable<__VLS_PickNotAny<
+		'__ctx' extends keyof __VLS_PickNotAny<K, {}> ? K extends { __ctx?: infer Ctx } ? Ctx : never : any
+		, T extends (props: any, ctx: infer Ctx) => any ? Ctx : any
+	>>;
+	type __VLS_UseTemplateRef<T> = Readonly<import('${lib}').ShallowRef<T | null>>;
+
+	function __VLS_getVForSourceType(source: number): [number, number, number][];
+	function __VLS_getVForSourceType(source: string): [string, number, number][];
+	function __VLS_getVForSourceType<T extends any[]>(source: T): [
+		item: T[number],
+		key: number,
+		index: number,
+	][];
+	function __VLS_getVForSourceType<T extends { [Symbol.iterator](): Iterator<any> }>(source: T): [
+		item: T extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never, 
+		key: number,
+		index: undefined,
+	][];
+	// #3845
+	function __VLS_getVForSourceType<T extends number | { [Symbol.iterator](): Iterator<any> }>(source: T): [
+		item: number | (Exclude<T, number> extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never), 
+		key: number,
+		index: undefined,
+	][];
+	function __VLS_getVForSourceType<T>(source: T): [
+		item: T[keyof T],
+		key: keyof T,
+		index: number,
+	][];
+	// @ts-ignore
+	function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
+	// @ts-ignore
+	function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
+	function __VLS_asFunctionalDirective<T>(dir: T): T extends import('${lib}').ObjectDirective
+		? NonNullable<T['created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted']>
+		: T extends (...args: any) => any
+			? T
+			: __VLS_unknownDirective;
+	function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
+	function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
+	function __VLS_nonNullable<T>(t: T): T extends null | undefined ? never : T;
+	function __VLS_asFunctionalComponent<T, K = T extends new (...args: any) => any ? InstanceType<T> : unknown>(t: T, instance?: K):
+		T extends new (...args: any) => any
+		? (props: ${fnPropsType}, ctx?: any) => __VLS_Element & { __ctx?: {
+			attrs?: any,
+			slots?: K extends { ${(0, shared_1.getSlotsPropertyName)(target)}: infer Slots } ? Slots : any,
+			emit?: K extends { $emit: infer Emit } ? Emit : any
+		} & { props?: ${fnPropsType}; expose?(exposed: K): void; } }
+		: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
+		: T extends (...args: any) => any ? T
+		: (_: {}${strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${strictTemplates ? '' : ' & Record<string, unknown>'} } };
+	function __VLS_elementAsFunction<T>(tag: T, endTag?: T): (_: T${strictTemplates ? '' : ' & Record<string, unknown>'}) => void;
+	function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): 2 extends Parameters<T>['length'] ? [any] : [];
+	function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
+	function __VLS_tryAsConstant<const T>(t: T): T;
+}
+`;
+    return text;
+}
+;
+//# sourceMappingURL=globalTypes.js.map

node_modules/@vue/language-core/lib/codegen/inlayHints.d.ts

@@ -0,0 +1,11 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+export interface InlayHintInfo {
+    blockName: string;
+    offset: number;
+    setting: string;
+    label: string;
+    tooltip?: string;
+    paddingRight?: boolean;
+    paddingLeft?: boolean;
+}
+export declare function createVBindShorthandInlayHintInfo(loc: CompilerDOM.SourceLocation, variableName: string): InlayHintInfo;

node_modules/@vue/language-core/lib/codegen/inlayHints.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVBindShorthandInlayHintInfo = createVBindShorthandInlayHintInfo;
+function createVBindShorthandInlayHintInfo(loc, variableName) {
+    return {
+        blockName: 'template',
+        offset: loc.end.offset,
+        setting: 'vue.inlayHints.vBindShorthand',
+        label: `="${variableName}"`,
+        tooltip: [
+            `This is a shorthand for \`${loc.source}="${variableName}"\`.`,
+            'To hide this hint, set `vue.inlayHints.vBindShorthand` to `false` in IDE settings.',
+            '[More info](https://github.com/vuejs/core/pull/9451)',
+        ].join('\n\n'),
+    };
+}
+//# sourceMappingURL=inlayHints.js.map

node_modules/@vue/language-core/lib/codegen/localTypes.d.ts

@@ -0,0 +1,13 @@
+import type * as ts from 'typescript';
+import { VueCompilerOptions } from '../types';
+export declare function getLocalTypesGenerator(compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): {
+    generate: (names: string[]) => Generator<string, void, unknown>;
+    getUsedNames(): Set<string>;
+    readonly PrettifyLocal: string;
+    readonly OmitKeepDiscriminatedUnion: string;
+    readonly WithDefaults: string;
+    readonly WithTemplateSlots: string;
+    readonly PropsChildren: string;
+    readonly TypePropsToOption: string;
+    readonly OmitIndexSignature: string;
+};

node_modules/@vue/language-core/lib/codegen/localTypes.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalTypesGenerator = getLocalTypesGenerator;
+const shared_1 = require("../utils/shared");
+const common_1 = require("./common");
+function getLocalTypesGenerator(compilerOptions, vueCompilerOptions) {
+    const used = new Set();
+    const OmitKeepDiscriminatedUnion = defineHelper(`__VLS_OmitKeepDiscriminatedUnion`, () => `
+type __VLS_OmitKeepDiscriminatedUnion<T, K extends keyof any> = T extends any
+	? Pick<T, Exclude<keyof T, K>>
+	: never;
+`.trimStart());
+    const WithDefaults = defineHelper(`__VLS_WithDefaults`, () => `
+type __VLS_WithDefaults<P, D> = {
+	[K in keyof Pick<P, keyof P>]: K extends keyof D
+		? ${PrettifyLocal.name}<P[K] & { default: D[K]}>
+		: P[K]
+};
+`.trimStart());
+    const PrettifyLocal = defineHelper(`__VLS_PrettifyLocal`, () => `type __VLS_PrettifyLocal<T> = { [K in keyof T]: T[K]; } & {}${common_1.endOfLine}`);
+    const WithTemplateSlots = defineHelper(`__VLS_WithTemplateSlots`, () => `
+type __VLS_WithTemplateSlots<T, S> = T & {
+	new(): {
+		${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: S;
+		${vueCompilerOptions.jsxSlots ? `$props: ${PropsChildren.name}<S>;` : ''}
+	}
+};
+`.trimStart());
+    const PropsChildren = defineHelper(`__VLS_PropsChildren`, () => `
+type __VLS_PropsChildren<S> = {
+	[K in keyof (
+		boolean extends (
+			// @ts-ignore
+			JSX.ElementChildrenAttribute extends never
+				? true
+				: false
+		)
+			? never
+			// @ts-ignore
+			: JSX.ElementChildrenAttribute
+	)]?: S;
+};
+`.trimStart());
+    const TypePropsToOption = defineHelper(`__VLS_TypePropsToOption`, () => compilerOptions.exactOptionalPropertyTypes ?
+        `
+type __VLS_TypePropsToOption<T> = {
+	[K in keyof T]-?: {} extends Pick<T, K>
+		? { type: import('${vueCompilerOptions.lib}').PropType<T[K]> }
+		: { type: import('${vueCompilerOptions.lib}').PropType<T[K]>, required: true }
+};
+`.trimStart() :
+        `
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+	[K in keyof T]-?: {} extends Pick<T, K>
+		? { type: import('${vueCompilerOptions.lib}').PropType<__VLS_NonUndefinedable<T[K]>> }
+		: { type: import('${vueCompilerOptions.lib}').PropType<T[K]>, required: true }
+};
+`.trimStart());
+    const OmitIndexSignature = defineHelper(`__VLS_OmitIndexSignature`, () => `type __VLS_OmitIndexSignature<T> = { [K in keyof T as {} extends Record<K, unknown> ? never : K]: T[K]; }${common_1.endOfLine}`);
+    const helpers = {
+        [PrettifyLocal.name]: PrettifyLocal,
+        [OmitKeepDiscriminatedUnion.name]: OmitKeepDiscriminatedUnion,
+        [WithDefaults.name]: WithDefaults,
+        [WithTemplateSlots.name]: WithTemplateSlots,
+        [PropsChildren.name]: PropsChildren,
+        [TypePropsToOption.name]: TypePropsToOption,
+        [OmitIndexSignature.name]: OmitIndexSignature,
+    };
+    used.clear();
+    return {
+        generate,
+        getUsedNames() {
+            return used;
+        },
+        get PrettifyLocal() { return PrettifyLocal.name; },
+        get OmitKeepDiscriminatedUnion() { return OmitKeepDiscriminatedUnion.name; },
+        get WithDefaults() { return WithDefaults.name; },
+        get WithTemplateSlots() { return WithTemplateSlots.name; },
+        get PropsChildren() { return PropsChildren.name; },
+        get TypePropsToOption() { return TypePropsToOption.name; },
+        get OmitIndexSignature() { return OmitIndexSignature.name; },
+    };
+    function* generate(names) {
+        const generated = new Set();
+        while (names.length) {
+            used.clear();
+            for (const name of names) {
+                if (generated.has(name)) {
+                    continue;
+                }
+                const helper = helpers[name];
+                yield helper.generate();
+                generated.add(name);
+            }
+            names = [...used].filter(name => !generated.has(name));
+        }
+    }
+    function defineHelper(name, generate) {
+        return {
+            get name() {
+                used.add(name);
+                return name;
+            },
+            generate,
+        };
+    }
+}
+//# sourceMappingURL=localTypes.js.map

node_modules/@vue/language-core/lib/codegen/script/component.d.ts

@@ -0,0 +1,8 @@
+import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
+import type { Code, Sfc } from '../../types';
+import type { ScriptCodegenContext } from './context';
+import { 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 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>;

node_modules/@vue/language-core/lib/codegen/script/component.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateComponent = generateComponent;
+exports.generateComponentSetupReturns = generateComponentSetupReturns;
+exports.generateEmitsOption = generateEmitsOption;
+exports.generatePropsOption = generatePropsOption;
+const common_1 = require("../common");
+const index_1 = require("./index");
+function* generateComponent(options, ctx, scriptSetup, scriptSetupRanges) {
+    if (options.sfc.script && options.scriptRanges?.exportDefault && options.scriptRanges.exportDefault.expression.start !== options.scriptRanges.exportDefault.args.start) {
+        // use defineComponent() from user space code if it exist
+        yield (0, common_1.generateSfcBlockSection)(options.sfc.script, options.scriptRanges.exportDefault.expression.start, options.scriptRanges.exportDefault.args.start, index_1.codeFeatures.all);
+        yield `{${common_1.newLine}`;
+    }
+    else {
+        yield `(await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
+    }
+    yield `setup() {${common_1.newLine}`;
+    yield `return {${common_1.newLine}`;
+    if (ctx.bypassDefineComponent) {
+        yield* generateComponentSetupReturns(scriptSetupRanges);
+    }
+    if (scriptSetupRanges.expose.define) {
+        yield `...__VLS_exposed,${common_1.newLine}`;
+    }
+    yield `}${common_1.endOfLine}`;
+    yield `},${common_1.newLine}`;
+    if (!ctx.bypassDefineComponent) {
+        const emitOptionCodes = [...generateEmitsOption(options, scriptSetupRanges)];
+        for (const code of emitOptionCodes) {
+            yield code;
+        }
+        yield* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, !!emitOptionCodes.length, true);
+    }
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.args) {
+        const { args } = options.scriptRanges.exportDefault;
+        yield (0, common_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, index_1.codeFeatures.all);
+    }
+    if (options.vueCompilerOptions.target >= 3.5 && scriptSetupRanges.templateRefs.length) {
+        yield `__typeRefs: {} as __VLS_TemplateResult['refs'],${common_1.newLine}`;
+    }
+    if (options.vueCompilerOptions.target >= 3.5 && options.templateCodegen?.singleRootElType) {
+        yield `__typeEl: {} as __VLS_TemplateResult['rootEl'],${common_1.newLine}`;
+    }
+    yield `})`;
+}
+function* generateComponentSetupReturns(scriptSetupRanges) {
+    // fill $props
+    if (scriptSetupRanges.props.define) {
+        // NOTE: defineProps is inaccurate for $props
+        yield `$props: __VLS_makeOptional(${scriptSetupRanges.props.name ?? `__VLS_props`}),${common_1.newLine}`;
+        yield `...${scriptSetupRanges.props.name ?? `__VLS_props`},${common_1.newLine}`;
+    }
+    // fill $emit
+    if (scriptSetupRanges.emits.define) {
+        yield `$emit: ${scriptSetupRanges.emits.name ?? '__VLS_emit'},${common_1.newLine}`;
+    }
+}
+function* generateEmitsOption(options, scriptSetupRanges) {
+    const codes = [];
+    if (scriptSetupRanges.defineProp.some(p => p.isModel)) {
+        codes.push({
+            optionExp: `{} as __VLS_NormalizeEmits<typeof __VLS_modelEmit>`,
+            typeOptionType: `__VLS_ModelEmit`,
+        });
+    }
+    if (scriptSetupRanges.emits.define) {
+        const { typeArg, hasUnionTypeArg } = scriptSetupRanges.emits.define;
+        codes.push({
+            optionExp: `{} as __VLS_NormalizeEmits<typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'}>`,
+            typeOptionType: typeArg && !hasUnionTypeArg
+                ? `__VLS_Emit`
+                : undefined,
+        });
+    }
+    if (options.vueCompilerOptions.target >= 3.5 && codes.every(code => code.typeOptionType)) {
+        if (codes.length === 1) {
+            yield `__typeEmits: {} as `;
+            yield codes[0].typeOptionType;
+            yield `,${common_1.newLine}`;
+        }
+        else if (codes.length >= 2) {
+            yield `__typeEmits: {} as `;
+            yield codes[0].typeOptionType;
+            for (let i = 1; i < codes.length; i++) {
+                yield ` & `;
+                yield codes[i].typeOptionType;
+            }
+            yield `,${common_1.newLine}`;
+        }
+    }
+    else if (codes.every(code => code.optionExp)) {
+        if (codes.length === 1) {
+            yield `emits: `;
+            yield codes[0].optionExp;
+            yield `,${common_1.newLine}`;
+        }
+        else if (codes.length >= 2) {
+            yield `emits: {${common_1.newLine}`;
+            for (const code of codes) {
+                yield `...`;
+                yield code.optionExp;
+                yield `,${common_1.newLine}`;
+            }
+            yield `},${common_1.newLine}`;
+        }
+    }
+}
+function* generatePropsOption(options, ctx, scriptSetup, scriptSetupRanges, hasEmitsOption, inheritAttrs) {
+    const codes = [];
+    if (ctx.generatedPropsType) {
+        codes.push({
+            optionExp: [
+                `{} as `,
+                scriptSetupRanges.props.withDefaults?.arg ? `${ctx.localTypes.WithDefaults}<` : '',
+                `${ctx.localTypes.TypePropsToOption}<__VLS_PublicProps>`,
+                scriptSetupRanges.props.withDefaults?.arg ? `, typeof __VLS_withDefaultsArg>` : '',
+            ].join(''),
+            typeOptionExp: `{} as __VLS_PublicProps`,
+        });
+    }
+    if (scriptSetupRanges.props.define?.arg) {
+        const { arg } = scriptSetupRanges.props.define;
+        codes.push({
+            optionExp: (0, common_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, index_1.codeFeatures.navigation),
+            typeOptionExp: undefined,
+        });
+    }
+    if (inheritAttrs && options.templateCodegen?.inheritedAttrVars.size) {
+        let attrsType = `__VLS_TemplateResult['attrs']`;
+        if (hasEmitsOption) {
+            attrsType = `Omit<${attrsType}, \`on\${string}\`>`;
+        }
+        const propsType = `__VLS_PickNotAny<${ctx.localTypes.OmitIndexSignature}<${attrsType}>, {}>`;
+        const optionType = `${ctx.localTypes.TypePropsToOption}<${propsType}>`;
+        codes.unshift({
+            optionExp: codes.length
+                ? `{} as ${optionType}`
+                // workaround for https://github.com/vuejs/core/pull/7419
+                : `{} as keyof ${propsType} extends never ? never: ${optionType}`,
+            typeOptionExp: `{} as ${attrsType}`,
+        });
+    }
+    const useTypeOption = options.vueCompilerOptions.target >= 3.5 && codes.every(code => code.typeOptionExp);
+    const useOption = !useTypeOption || scriptSetupRanges.props.withDefaults;
+    if (useTypeOption) {
+        if (codes.length === 1) {
+            yield `__typeProps: `;
+            yield codes[0].typeOptionExp;
+            yield `,${common_1.newLine}`;
+        }
+        else if (codes.length >= 2) {
+            yield `__typeProps: {${common_1.newLine}`;
+            for (const { typeOptionExp } of codes) {
+                yield `...`;
+                yield typeOptionExp;
+                yield `,${common_1.newLine}`;
+            }
+            yield `},${common_1.newLine}`;
+        }
+    }
+    if (useOption) {
+        if (codes.length === 1) {
+            yield `props: `;
+            yield codes[0].optionExp;
+            yield `,${common_1.newLine}`;
+        }
+        else if (codes.length >= 2) {
+            yield `props: {${common_1.newLine}`;
+            for (const { optionExp } of codes) {
+                yield `...`;
+                yield optionExp;
+                yield `,${common_1.newLine}`;
+            }
+            yield `},${common_1.newLine}`;
+        }
+    }
+}
+//# sourceMappingURL=component.js.map

node_modules/@vue/language-core/lib/codegen/script/componentSelf.d.ts

@@ -0,0 +1,5 @@
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from '../template/context';
+import type { ScriptCodegenContext } from './context';
+import { type ScriptCodegenOptions } from './index';
+export declare function generateComponentSelf(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, templateCodegenCtx: TemplateCodegenContext): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/componentSelf.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateComponentSelf = generateComponentSelf;
+const path = require("path-browserify");
+const common_1 = require("../common");
+const component_1 = require("./component");
+const index_1 = require("./index");
+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({${common_1.newLine}`;
+        yield `setup() {${common_1.newLine}`;
+        yield `return {${common_1.newLine}`;
+        if (ctx.bypassDefineComponent) {
+            yield* (0, component_1.generateComponentSetupReturns)(options.scriptSetupRanges);
+        }
+        // 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 expose of bindings) {
+                const varName = content.substring(expose.start, expose.end);
+                if (!templateUsageVars.has(varName) && !templateCodegenCtx.accessExternalVariables.has(varName)) {
+                    continue;
+                }
+                const templateOffset = options.getGeneratedLength();
+                yield `${varName}: ${varName} as typeof `;
+                const scriptOffset = options.getGeneratedLength();
+                yield `${varName},${common_1.newLine}`;
+                options.linkedCodeMappings.push({
+                    sourceOffsets: [scriptOffset],
+                    generatedOffsets: [templateOffset],
+                    lengths: [varName.length],
+                    data: undefined,
+                });
+            }
+        }
+        yield `}${common_1.endOfLine}`; // return {
+        yield `},${common_1.newLine}`; // setup() {
+        if (options.sfc.scriptSetup && options.scriptSetupRanges && !ctx.bypassDefineComponent) {
+            const emitOptionCodes = [...(0, component_1.generateEmitsOption)(options, options.scriptSetupRanges)];
+            for (const code of emitOptionCodes) {
+                yield code;
+            }
+            yield* (0, component_1.generatePropsOption)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges, !!emitOptionCodes.length, false);
+        }
+        if (options.sfc.script && options.scriptRanges?.exportDefault?.args) {
+            const { args } = options.scriptRanges.exportDefault;
+            yield (0, common_1.generateSfcBlockSection)(options.sfc.script, args.start + 1, args.end - 1, index_1.codeFeatures.all);
+        }
+        yield `})${common_1.endOfLine}`; // defineComponent {
+    }
+    else if (options.sfc.script) {
+        yield `let __VLS_self!: typeof import('./${path.basename(options.fileName)}').default${common_1.endOfLine}`;
+    }
+    else {
+        yield `const __VLS_self = (await import('${options.vueCompilerOptions.lib}')).defineComponent({})${common_1.endOfLine}`;
+    }
+}
+//# sourceMappingURL=componentSelf.js.map

node_modules/@vue/language-core/lib/codegen/script/context.d.ts

@@ -0,0 +1,28 @@
+import { 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;
+    generatedPropsType: boolean;
+    scriptSetupGeneratedOffset: number | undefined;
+    bypassDefineComponent: boolean;
+    bindingNames: Set<string>;
+    localTypes: {
+        generate: (names: string[]) => Generator<string, void, unknown>;
+        getUsedNames(): Set<string>;
+        readonly PrettifyLocal: string;
+        readonly OmitKeepDiscriminatedUnion: string;
+        readonly WithDefaults: string;
+        readonly WithTemplateSlots: string;
+        readonly PropsChildren: string;
+        readonly TypePropsToOption: string;
+        readonly OmitIndexSignature: string;
+    };
+    inlayHints: InlayHintInfo[];
+};

node_modules/@vue/language-core/lib/codegen/script/context.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScriptCodegenContext = createScriptCodegenContext;
+const localTypes_1 = require("../localTypes");
+function createScriptCodegenContext(options) {
+    const localTypes = (0, localTypes_1.getLocalTypesGenerator)(options.compilerOptions, options.vueCompilerOptions);
+    const inlayHints = [];
+    return {
+        generatedTemplate: false,
+        generatedPropsType: false,
+        scriptSetupGeneratedOffset: undefined,
+        bypassDefineComponent: options.lang === 'js' || options.lang === 'jsx',
+        bindingNames: new Set([
+            ...options.scriptRanges?.bindings.map(range => options.sfc.script.content.substring(range.start, range.end)) ?? [],
+            ...options.scriptSetupRanges?.bindings.map(range => options.sfc.scriptSetup.content.substring(range.start, range.end)) ?? [],
+        ]),
+        localTypes,
+        inlayHints,
+    };
+}
+//# sourceMappingURL=context.js.map

node_modules/@vue/language-core/lib/codegen/script/index.d.ts

@@ -0,0 +1,33 @@
+import type { Mapping } from '@volar/language-core';
+import type * as ts from 'typescript';
+import type { ScriptRanges } from '../../parsers/scriptRanges';
+import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
+import type { Code, Sfc, VueCodeInformation, VueCompilerOptions } from '../../types';
+import type { TemplateCodegenContext } from '../template/context';
+import { ScriptCodegenContext } from './context';
+export declare const codeFeatures: {
+    all: VueCodeInformation;
+    none: VueCodeInformation;
+    verification: VueCodeInformation;
+    navigation: VueCodeInformation;
+    navigationWithoutRename: VueCodeInformation;
+};
+export interface ScriptCodegenOptions {
+    fileName: string;
+    ts: typeof ts;
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    sfc: Sfc;
+    lang: string;
+    scriptRanges: ScriptRanges | undefined;
+    scriptSetupRanges: ScriptSetupRanges | undefined;
+    templateCodegen: TemplateCodegenContext & {
+        codes: Code[];
+    } | undefined;
+    edited: boolean;
+    appendGlobalTypes: boolean;
+    getGeneratedLength: () => number;
+    linkedCodeMappings: Mapping[];
+}
+export declare function generateScript(options: ScriptCodegenOptions): Generator<Code, ScriptCodegenContext>;
+export declare function generateScriptSectionPartiallyEnding(source: string, end: number, mark: string): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/index.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeFeatures = void 0;
+exports.generateScript = generateScript;
+exports.generateScriptSectionPartiallyEnding = generateScriptSectionPartiallyEnding;
+const path = require("path-browserify");
+const common_1 = require("../common");
+const globalTypes_1 = require("../globalTypes");
+const componentSelf_1 = require("./componentSelf");
+const context_1 = require("./context");
+const scriptSetup_1 = require("./scriptSetup");
+const src_1 = require("./src");
+const styleModulesType_1 = require("./styleModulesType");
+const template_1 = require("./template");
+exports.codeFeatures = {
+    all: {
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+    },
+    none: {},
+    verification: {
+        verification: true,
+    },
+    navigation: {
+        navigation: true,
+    },
+    navigationWithoutRename: {
+        navigation: {
+            shouldRename() {
+                return false;
+            },
+        },
+    },
+};
+function* generateScript(options) {
+    const ctx = (0, context_1.createScriptCodegenContext)(options);
+    if (options.vueCompilerOptions.__setupedGlobalTypes) {
+        const globalTypes = options.vueCompilerOptions.__setupedGlobalTypes;
+        if (typeof globalTypes === 'object') {
+            let relativePath = path.relative(path.dirname(options.fileName), globalTypes.absolutePath);
+            if (relativePath !== globalTypes.absolutePath && !relativePath.startsWith('./') && !relativePath.startsWith('../')) {
+                relativePath = './' + relativePath;
+            }
+            yield `/// <reference types="${relativePath}" />${common_1.newLine}`;
+        }
+        else {
+            yield `/// <reference types=".vue-global-types/${options.vueCompilerOptions.lib}_${options.vueCompilerOptions.target}_${options.vueCompilerOptions.strictTemplates}.d.ts" />${common_1.newLine}`;
+        }
+    }
+    else {
+        yield `/* placeholder */`;
+    }
+    if (options.sfc.script?.src) {
+        yield* (0, src_1.generateSrc)(options.sfc.script, options.sfc.script.src);
+    }
+    if (options.sfc.script && options.scriptRanges) {
+        const { exportDefault, classBlockEnd } = options.scriptRanges;
+        const isExportRawObject = exportDefault
+            && options.sfc.script.content[exportDefault.expression.start] === '{';
+        if (options.sfc.scriptSetup && options.scriptSetupRanges) {
+            yield* (0, scriptSetup_1.generateScriptSetupImports)(options.sfc.scriptSetup, options.scriptSetupRanges);
+            yield* generateDefineProp(options, options.sfc.scriptSetup);
+            if (exportDefault) {
+                yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, exportDefault.expression.start, exports.codeFeatures.all);
+                yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
+                yield (0, common_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.end, options.sfc.script.content.length, exports.codeFeatures.all);
+            }
+            else {
+                yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, exports.codeFeatures.all);
+                yield* generateScriptSectionPartiallyEnding(options.sfc.script.name, options.sfc.script.content.length, '#3632/both.vue');
+                yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
+            }
+        }
+        else if (exportDefault && isExportRawObject && options.vueCompilerOptions.optionsWrapper.length) {
+            ctx.inlayHints.push({
+                blockName: options.sfc.script.name,
+                offset: exportDefault.expression.start,
+                setting: 'vue.inlayHints.optionsWrapper',
+                label: options.vueCompilerOptions.optionsWrapper.length
+                    ? options.vueCompilerOptions.optionsWrapper[0]
+                    : '[Missing optionsWrapper[0]]',
+                tooltip: [
+                    'This is virtual code that is automatically wrapped for type support, it does not affect your runtime behavior, you can customize it via `vueCompilerOptions.optionsWrapper` option in tsconfig / jsconfig.',
+                    'To hide it, you can set `"vue.inlayHints.optionsWrapper": false` in IDE settings.',
+                ].join('\n\n'),
+            }, {
+                blockName: options.sfc.script.name,
+                offset: exportDefault.expression.end,
+                setting: 'vue.inlayHints.optionsWrapper',
+                label: options.vueCompilerOptions.optionsWrapper.length >= 2
+                    ? options.vueCompilerOptions.optionsWrapper[1]
+                    : '[Missing optionsWrapper[1]]',
+            });
+            yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, exportDefault.expression.start, exports.codeFeatures.all);
+            yield options.vueCompilerOptions.optionsWrapper[0];
+            yield (0, common_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.start, exportDefault.expression.end, exports.codeFeatures.all);
+            yield options.vueCompilerOptions.optionsWrapper[1];
+            yield (0, common_1.generateSfcBlockSection)(options.sfc.script, exportDefault.expression.end, options.sfc.script.content.length, exports.codeFeatures.all);
+        }
+        else if (classBlockEnd !== undefined) {
+            if (options.vueCompilerOptions.skipTemplateCodegen) {
+                yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, exports.codeFeatures.all);
+            }
+            else {
+                yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, classBlockEnd, exports.codeFeatures.all);
+                yield `__VLS_template = () => {${common_1.newLine}`;
+                const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
+                yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
+                yield `}${common_1.endOfLine}`;
+                yield (0, common_1.generateSfcBlockSection)(options.sfc.script, classBlockEnd, options.sfc.script.content.length, exports.codeFeatures.all);
+            }
+        }
+        else {
+            yield (0, common_1.generateSfcBlockSection)(options.sfc.script, 0, options.sfc.script.content.length, exports.codeFeatures.all);
+        }
+    }
+    else if (options.sfc.scriptSetup && options.scriptSetupRanges) {
+        yield* (0, scriptSetup_1.generateScriptSetupImports)(options.sfc.scriptSetup, options.scriptSetupRanges);
+        yield* generateDefineProp(options, options.sfc.scriptSetup);
+        yield* (0, scriptSetup_1.generateScriptSetup)(options, ctx, options.sfc.scriptSetup, options.scriptSetupRanges);
+    }
+    if (options.sfc.script) {
+        yield* generateScriptSectionPartiallyEnding(options.sfc.script.name, options.sfc.script.content.length, '#3632/script.vue');
+    }
+    if (options.sfc.scriptSetup) {
+        yield* generateScriptSectionPartiallyEnding(options.sfc.scriptSetup.name, options.sfc.scriptSetup.content.length, '#4569/main.vue');
+    }
+    if (!ctx.generatedTemplate) {
+        yield `function __VLS_template() {${common_1.newLine}`;
+        const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
+        yield `}${common_1.endOfLine}`;
+        yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
+    }
+    // #4788
+    yield* (0, styleModulesType_1.generateStyleModulesType)(options, ctx);
+    if (options.edited) {
+        yield `type __VLS_IntrinsicElementsCompletion = __VLS_IntrinsicElements${common_1.endOfLine}`;
+    }
+    yield* ctx.localTypes.generate([...ctx.localTypes.getUsedNames()]);
+    if (options.appendGlobalTypes) {
+        yield (0, globalTypes_1.generateGlobalTypes)(options.vueCompilerOptions.lib, options.vueCompilerOptions.target, options.vueCompilerOptions.strictTemplates);
+    }
+    if (options.sfc.scriptSetup) {
+        yield ['', 'scriptSetup', options.sfc.scriptSetup.content.length, exports.codeFeatures.verification];
+    }
+    return ctx;
+}
+function* generateScriptSectionPartiallyEnding(source, end, mark) {
+    yield `;`;
+    yield ['', source, end, exports.codeFeatures.verification];
+    yield `/* PartiallyEnd: ${mark} */${common_1.newLine}`;
+}
+function* generateDefineProp(options, scriptSetup) {
+    const definePropProposalA = scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition') || options.vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';
+    const definePropProposalB = scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition') || options.vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition';
+    if (definePropProposalA || definePropProposalB) {
+        yield `type __VLS_PropOptions<T> = Exclude<import('${options.vueCompilerOptions.lib}').Prop<T>, import('${options.vueCompilerOptions.lib}').PropType<T>>${common_1.endOfLine}`;
+        if (definePropProposalA) {
+            yield `declare function defineProp<T>(name: string, options: ({ required: true } | { default: T }) & __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${common_1.endOfLine}`;
+            yield `declare function defineProp<T>(name?: string, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T | undefined>${common_1.endOfLine}`;
+        }
+        if (definePropProposalB) {
+            yield `declare function defineProp<T>(value: T | (() => T), required?: boolean, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${common_1.endOfLine}`;
+            yield `declare function defineProp<T>(value: T | (() => T) | undefined, required: true, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T>${common_1.endOfLine}`;
+            yield `declare function defineProp<T>(value?: T | (() => T), required?: boolean, options?: __VLS_PropOptions<T>): import('${options.vueCompilerOptions.lib}').ComputedRef<T | undefined>${common_1.endOfLine}`;
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

node_modules/@vue/language-core/lib/codegen/script/scriptSetup.d.ts

@@ -0,0 +1,6 @@
+import type { ScriptSetupRanges } from '../../parsers/scriptSetupRanges';
+import type { Code, Sfc } from '../../types';
+import type { ScriptCodegenContext } from './context';
+import { ScriptCodegenOptions } from './index';
+export declare function generateScriptSetupImports(scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;
+export declare function generateScriptSetup(options: ScriptCodegenOptions, ctx: ScriptCodegenContext, scriptSetup: NonNullable<Sfc['scriptSetup']>, scriptSetupRanges: ScriptSetupRanges): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/scriptSetup.js

@@ -0,0 +1,438 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateScriptSetupImports = generateScriptSetupImports;
+exports.generateScriptSetup = generateScriptSetup;
+const common_1 = require("../common");
+const component_1 = require("./component");
+const componentSelf_1 = require("./componentSelf");
+const index_1 = require("./index");
+const template_1 = require("./template");
+function* generateScriptSetupImports(scriptSetup, scriptSetupRanges) {
+    yield [
+        scriptSetup.content.substring(0, Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset)),
+        'scriptSetup',
+        0,
+        index_1.codeFeatures.all,
+    ];
+    yield common_1.newLine;
+}
+function* generateScriptSetup(options, ctx, scriptSetup, scriptSetupRanges) {
+    const definePropMirrors = new Map();
+    if (scriptSetup.generic) {
+        if (!options.scriptRanges?.exportDefault) {
+            if (options.sfc.scriptSetup) {
+                // #4569
+                yield [
+                    '',
+                    'scriptSetup',
+                    options.sfc.scriptSetup.content.length,
+                    index_1.codeFeatures.verification,
+                ];
+            }
+            yield `export default `;
+        }
+        yield `(<`;
+        yield [
+            scriptSetup.generic,
+            scriptSetup.name,
+            scriptSetup.genericOffset,
+            index_1.codeFeatures.all,
+        ];
+        if (!scriptSetup.generic.endsWith(`,`)) {
+            yield `,`;
+        }
+        yield `>(${common_1.newLine}`
+            + `	__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>['props'],${common_1.newLine}`
+            + `	__VLS_ctx?: ${ctx.localTypes.PrettifyLocal}<Pick<NonNullable<Awaited<typeof __VLS_setup>>, 'attrs' | 'emit' | 'slots'>>,${common_1.newLine}` // use __VLS_Prettify for less dts code
+            + `	__VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>['expose'],${common_1.newLine}`
+            + `	__VLS_setup = (async () => {${common_1.newLine}`;
+        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, undefined, definePropMirrors);
+        const emitTypes = [];
+        if (scriptSetupRanges.emits.define) {
+            emitTypes.push(`typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'}`);
+        }
+        if (scriptSetupRanges.defineProp.some(p => p.isModel)) {
+            emitTypes.push(`typeof __VLS_modelEmit`);
+        }
+        yield `		return {} as {${common_1.newLine}`
+            + `			props: ${ctx.localTypes.PrettifyLocal}<typeof __VLS_functionalComponentProps & __VLS_TemplateResult['attrs'] & __VLS_PublicProps> & __VLS_BuiltInPublicProps,${common_1.newLine}`
+            + `			expose(exposed: import('${options.vueCompilerOptions.lib}').ShallowUnwrapRef<${scriptSetupRanges.expose.define ? 'typeof __VLS_exposed' : '{}'}>): void,${common_1.newLine}`
+            + `			attrs: any,${common_1.newLine}`
+            + `			slots: __VLS_TemplateResult['slots'],${common_1.newLine}`
+            + `			emit: ${emitTypes.length ? emitTypes.join(' & ') : `{}`},${common_1.newLine}`
+            + `		}${common_1.endOfLine}`;
+        yield `	})(),${common_1.newLine}`; // __VLS_setup = (async () => {
+        yield `) => ({} as import('${options.vueCompilerOptions.lib}').VNode & { __ctx?: Awaited<typeof __VLS_setup> }))`;
+    }
+    else if (!options.sfc.script) {
+        // no script block, generate script setup code at root
+        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, 'export default', definePropMirrors);
+    }
+    else {
+        if (!options.scriptRanges?.exportDefault) {
+            yield `export default `;
+        }
+        yield `await (async () => {${common_1.newLine}`;
+        yield* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, 'return', definePropMirrors);
+        yield `})()`;
+    }
+    if (ctx.scriptSetupGeneratedOffset !== undefined) {
+        for (const defineProp of scriptSetupRanges.defineProp) {
+            if (!defineProp.localName) {
+                continue;
+            }
+            const [_, localName] = getPropAndLocalName(scriptSetup, defineProp);
+            const propMirror = definePropMirrors.get(localName);
+            if (propMirror !== undefined) {
+                options.linkedCodeMappings.push({
+                    sourceOffsets: [defineProp.localName.start + ctx.scriptSetupGeneratedOffset],
+                    generatedOffsets: [propMirror],
+                    lengths: [defineProp.localName.end - defineProp.localName.start],
+                    data: undefined,
+                });
+            }
+        }
+    }
+}
+function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, syntax, definePropMirrors) {
+    if (options.vueCompilerOptions.target >= 3.3) {
+        yield `const { `;
+        for (const macro of Object.keys(options.vueCompilerOptions.macros)) {
+            if (!ctx.bindingNames.has(macro) && macro !== 'templateRef') {
+                yield macro + `, `;
+            }
+        }
+        yield `} = await import('${options.vueCompilerOptions.lib}')${common_1.endOfLine}`;
+    }
+    ctx.scriptSetupGeneratedOffset = options.getGeneratedLength() - scriptSetupRanges.importSectionEndOffset;
+    let setupCodeModifies = [];
+    if (scriptSetupRanges.props.define) {
+        setupCodeModifies.push(...generateDefineWithType(scriptSetup, scriptSetupRanges.props.name, scriptSetupRanges.props.define, scriptSetupRanges.props.withDefaults ?? scriptSetupRanges.props.define, '__VLS_props', '__VLS_Props'));
+    }
+    if (scriptSetupRanges.slots.define) {
+        if (scriptSetupRanges.slots.isObjectBindingPattern) {
+            setupCodeModifies.push([
+                [`__VLS_slots;\nconst __VLS_slots = `],
+                scriptSetupRanges.slots.define.start,
+                scriptSetupRanges.slots.define.start,
+            ]);
+        }
+        else if (!scriptSetupRanges.slots.name) {
+            setupCodeModifies.push([[`const __VLS_slots = `], scriptSetupRanges.slots.define.start, scriptSetupRanges.slots.define.start]);
+        }
+    }
+    if (scriptSetupRanges.emits.define) {
+        setupCodeModifies.push(...generateDefineWithType(scriptSetup, scriptSetupRanges.emits.name, scriptSetupRanges.emits.define, scriptSetupRanges.emits.define, '__VLS_emit', '__VLS_Emit'));
+    }
+    if (scriptSetupRanges.expose.define) {
+        if (scriptSetupRanges.expose.define?.typeArg) {
+            setupCodeModifies.push([
+                [
+                    `let __VLS_exposed!: `,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.expose.define.typeArg.start, scriptSetupRanges.expose.define.typeArg.end, index_1.codeFeatures.navigation),
+                    `${common_1.endOfLine}`,
+                ],
+                scriptSetupRanges.expose.define.start,
+                scriptSetupRanges.expose.define.start,
+            ]);
+        }
+        else if (scriptSetupRanges.expose.define?.arg) {
+            setupCodeModifies.push([
+                [
+                    `const __VLS_exposed = `,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.expose.define.arg.start, scriptSetupRanges.expose.define.arg.end, index_1.codeFeatures.navigation),
+                    `${common_1.endOfLine}`,
+                ],
+                scriptSetupRanges.expose.define.start,
+                scriptSetupRanges.expose.define.start,
+            ]);
+        }
+        else {
+            setupCodeModifies.push([
+                [`const __VLS_exposed = {}${common_1.endOfLine}`],
+                scriptSetupRanges.expose.define.start,
+                scriptSetupRanges.expose.define.start,
+            ]);
+        }
+    }
+    if (scriptSetupRanges.cssModules.length) {
+        for (const { define } of scriptSetupRanges.cssModules) {
+            setupCodeModifies.push([
+                [`(`],
+                define.start,
+                define.start
+            ], [
+                define.arg ? [
+                    ` as Omit<__VLS_StyleModules, '$style'>[`,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, define.arg.start, define.arg.end, index_1.codeFeatures.all),
+                    `])`
+                ] : [
+                    ` as __VLS_StyleModules[`,
+                    ['', scriptSetup.name, define.exp.start, index_1.codeFeatures.verification],
+                    `'$style'`,
+                    ['', scriptSetup.name, define.exp.end, index_1.codeFeatures.verification],
+                    `])`
+                ],
+                define.end,
+                define.end
+            ]);
+        }
+    }
+    const isTs = options.lang !== 'js' && options.lang !== 'jsx';
+    for (const { define } of scriptSetupRanges.templateRefs) {
+        if (!define.arg) {
+            continue;
+        }
+        if (isTs) {
+            setupCodeModifies.push([
+                [
+                    `<__VLS_TemplateResult['refs'][`,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, define.arg.start, define.arg.end, index_1.codeFeatures.navigation),
+                    `], keyof __VLS_TemplateResult['refs']>`
+                ],
+                define.exp.end,
+                define.exp.end
+            ]);
+        }
+        else {
+            setupCodeModifies.push([
+                [`(`],
+                define.start,
+                define.start
+            ], [
+                [
+                    ` as __VLS_UseTemplateRef<__VLS_TemplateResult['refs'][`,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, define.arg.start, define.arg.end, index_1.codeFeatures.navigation),
+                    `]>)`
+                ],
+                define.end,
+                define.end
+            ]);
+        }
+    }
+    setupCodeModifies = setupCodeModifies.sort((a, b) => a[1] - b[1]);
+    let nextStart = scriptSetupRanges.importSectionEndOffset;
+    for (const [codes, start, end] of setupCodeModifies) {
+        yield (0, common_1.generateSfcBlockSection)(scriptSetup, nextStart, start, index_1.codeFeatures.all);
+        for (const code of codes) {
+            yield code;
+        }
+        nextStart = end;
+    }
+    yield (0, common_1.generateSfcBlockSection)(scriptSetup, nextStart, scriptSetup.content.length, index_1.codeFeatures.all);
+    yield* (0, index_1.generateScriptSectionPartiallyEnding)(scriptSetup.name, scriptSetup.content.length, '#3632/scriptSetup.vue');
+    if (scriptSetupRanges.props.define?.typeArg && scriptSetupRanges.props.withDefaults?.arg) {
+        // fix https://github.com/vuejs/language-tools/issues/1187
+        yield `const __VLS_withDefaultsArg = (function <T>(t: T) { return t })(`;
+        yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.props.withDefaults.arg.start, scriptSetupRanges.props.withDefaults.arg.end, index_1.codeFeatures.navigation);
+        yield `)${common_1.endOfLine}`;
+    }
+    yield* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, definePropMirrors);
+    yield* generateModelEmit(scriptSetup, scriptSetupRanges);
+    yield `function __VLS_template() {${common_1.newLine}`;
+    const templateCodegenCtx = yield* (0, template_1.generateTemplate)(options, ctx);
+    yield `}${common_1.endOfLine}`;
+    yield* (0, componentSelf_1.generateComponentSelf)(options, ctx, templateCodegenCtx);
+    yield `type __VLS_TemplateResult = ReturnType<typeof __VLS_template>${common_1.endOfLine}`;
+    if (syntax) {
+        if (!options.vueCompilerOptions.skipTemplateCodegen && (options.templateCodegen?.hasSlot || scriptSetupRanges?.slots.define)) {
+            yield `const __VLS_component = `;
+            yield* (0, component_1.generateComponent)(options, ctx, scriptSetup, scriptSetupRanges);
+            yield common_1.endOfLine;
+            yield `${syntax} `;
+            yield `{} as ${ctx.localTypes.WithTemplateSlots}<typeof __VLS_component, __VLS_TemplateResult['slots']>${common_1.endOfLine}`;
+        }
+        else {
+            yield `${syntax} `;
+            yield* (0, component_1.generateComponent)(options, ctx, scriptSetup, scriptSetupRanges);
+            yield common_1.endOfLine;
+        }
+    }
+}
+function* generateDefineWithType(scriptSetup, name, define, expression, defaultName, typeName) {
+    const { statement, typeArg } = define;
+    if (typeArg) {
+        yield [[
+                `type ${typeName} = `,
+                (0, common_1.generateSfcBlockSection)(scriptSetup, typeArg.start, typeArg.end, index_1.codeFeatures.all),
+                common_1.endOfLine,
+            ], statement.start, statement.start];
+        yield [[typeName], typeArg.start, typeArg.end];
+    }
+    if (!name) {
+        if (statement.start === expression.start && statement.end === expression.end) {
+            yield [[`const ${defaultName} = `], expression.start, expression.start];
+        }
+        else if (typeArg) {
+            yield [[
+                    `const ${defaultName} = `,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, expression.start, typeArg.start, index_1.codeFeatures.all)
+                ], statement.start, typeArg.start];
+            yield [[
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, typeArg.end, expression.end, index_1.codeFeatures.all),
+                    common_1.endOfLine,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, statement.start, expression.start, index_1.codeFeatures.all),
+                    defaultName
+                ], typeArg.end, expression.end];
+        }
+        else {
+            yield [[
+                    `const ${defaultName} = `,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, expression.start, expression.end, index_1.codeFeatures.all),
+                    common_1.endOfLine,
+                    (0, common_1.generateSfcBlockSection)(scriptSetup, statement.start, expression.start, index_1.codeFeatures.all),
+                    defaultName
+                ], statement.start, expression.end];
+        }
+    }
+}
+function* generateComponentProps(options, ctx, scriptSetup, scriptSetupRanges, definePropMirrors) {
+    yield `const __VLS_fnComponent = (await import('${options.vueCompilerOptions.lib}')).defineComponent({${common_1.newLine}`;
+    if (scriptSetupRanges.props.define?.arg) {
+        yield `props: `;
+        yield (0, common_1.generateSfcBlockSection)(scriptSetup, scriptSetupRanges.props.define.arg.start, scriptSetupRanges.props.define.arg.end, index_1.codeFeatures.navigation);
+        yield `,${common_1.newLine}`;
+    }
+    yield* (0, component_1.generateEmitsOption)(options, scriptSetupRanges);
+    yield `})${common_1.endOfLine}`;
+    yield `type __VLS_BuiltInPublicProps = ${options.vueCompilerOptions.target >= 3.4
+        ? `import('${options.vueCompilerOptions.lib}').PublicProps;`
+        : options.vueCompilerOptions.target >= 3.0
+            ? `import('${options.vueCompilerOptions.lib}').VNodeProps
+					& import('${options.vueCompilerOptions.lib}').AllowedComponentProps
+					& import('${options.vueCompilerOptions.lib}').ComponentCustomProps;`
+            : `globalThis.JSX.IntrinsicAttributes;`}`;
+    yield common_1.endOfLine;
+    yield `let __VLS_functionalComponentProps!: `;
+    yield `${ctx.localTypes.OmitKeepDiscriminatedUnion}<InstanceType<typeof __VLS_fnComponent>['$props'], keyof __VLS_BuiltInPublicProps>`;
+    yield common_1.endOfLine;
+    if (scriptSetupRanges.defineProp.length) {
+        yield `const __VLS_defaults = {${common_1.newLine}`;
+        for (const defineProp of scriptSetupRanges.defineProp) {
+            if (defineProp.defaultValue) {
+                const [propName, localName] = getPropAndLocalName(scriptSetup, defineProp);
+                if (defineProp.name || defineProp.isModel) {
+                    yield propName;
+                }
+                else if (defineProp.localName) {
+                    yield localName;
+                }
+                else {
+                    continue;
+                }
+                yield `: `;
+                yield getRangeName(scriptSetup, defineProp.defaultValue);
+                yield `,${common_1.newLine}`;
+            }
+        }
+        yield `}${common_1.endOfLine}`;
+    }
+    yield `type __VLS_PublicProps = `;
+    if (scriptSetupRanges.slots.define && options.vueCompilerOptions.jsxSlots) {
+        if (ctx.generatedPropsType) {
+            yield ` & `;
+        }
+        ctx.generatedPropsType = true;
+        yield `${ctx.localTypes.PropsChildren}<typeof __VLS_slots>`;
+    }
+    if (scriptSetupRanges.defineProp.length) {
+        if (ctx.generatedPropsType) {
+            yield ` & `;
+        }
+        ctx.generatedPropsType = true;
+        yield `{${common_1.newLine}`;
+        for (const defineProp of scriptSetupRanges.defineProp) {
+            const [propName, localName] = getPropAndLocalName(scriptSetup, defineProp);
+            if (defineProp.isModel && !defineProp.name) {
+                yield propName;
+            }
+            else if (defineProp.name) {
+                // renaming support
+                yield (0, common_1.generateSfcBlockSection)(scriptSetup, defineProp.name.start, defineProp.name.end, index_1.codeFeatures.navigation);
+            }
+            else if (defineProp.localName) {
+                definePropMirrors.set(localName, options.getGeneratedLength());
+                yield localName;
+            }
+            else {
+                continue;
+            }
+            yield defineProp.required
+                ? `: `
+                : `?: `;
+            yield* generateDefinePropType(scriptSetup, propName, localName, defineProp);
+            yield `,${common_1.newLine}`;
+            if (defineProp.modifierType) {
+                let propModifierName = 'modelModifiers';
+                if (defineProp.name) {
+                    propModifierName = `${getRangeName(scriptSetup, defineProp.name, true)}Modifiers`;
+                }
+                const modifierType = getRangeName(scriptSetup, defineProp.modifierType);
+                definePropMirrors.set(propModifierName, options.getGeneratedLength());
+                yield `${propModifierName}?: Record<${modifierType}, true>,${common_1.endOfLine}`;
+            }
+        }
+        yield `}`;
+    }
+    if (scriptSetupRanges.props.define?.typeArg) {
+        if (ctx.generatedPropsType) {
+            yield ` & `;
+        }
+        ctx.generatedPropsType = true;
+        yield `__VLS_Props`;
+    }
+    if (!ctx.generatedPropsType) {
+        yield `{}`;
+    }
+    yield common_1.endOfLine;
+}
+function* generateModelEmit(scriptSetup, scriptSetupRanges) {
+    const defineModels = scriptSetupRanges.defineProp.filter(p => p.isModel);
+    if (defineModels.length) {
+        yield `type __VLS_ModelEmit = {${common_1.newLine}`;
+        for (const defineModel of defineModels) {
+            const [propName, localName] = getPropAndLocalName(scriptSetup, defineModel);
+            yield `'update:${propName}': [value:`;
+            yield* generateDefinePropType(scriptSetup, propName, localName, defineModel);
+            yield `]${common_1.endOfLine}`;
+        }
+        yield `}${common_1.endOfLine}`;
+        yield `const __VLS_modelEmit = defineEmits<__VLS_ModelEmit>()${common_1.endOfLine}`;
+    }
+}
+function* generateDefinePropType(scriptSetup, propName, localName, defineProp) {
+    if (defineProp.type) {
+        // Infer from defineProp<T>
+        yield getRangeName(scriptSetup, defineProp.type);
+    }
+    else if (defineProp.runtimeType && localName) {
+        // Infer from actual prop declaration code 
+        yield `typeof ${localName}['value']`;
+    }
+    else if (defineProp.defaultValue && propName) {
+        // Infer from defineProp({default: T})
+        yield `typeof __VLS_defaults['${propName}']`;
+    }
+    else {
+        yield `any`;
+    }
+}
+function getPropAndLocalName(scriptSetup, defineProp) {
+    const localName = defineProp.localName
+        ? getRangeName(scriptSetup, defineProp.localName)
+        : undefined;
+    let propName = defineProp.name
+        ? getRangeName(scriptSetup, defineProp.name)
+        : defineProp.isModel
+            ? 'modelValue'
+            : localName;
+    if (defineProp.name) {
+        propName = propName.replace(/['"]+/g, '');
+    }
+    return [propName, localName];
+}
+function getRangeName(scriptSetup, range, unwrap = false) {
+    const offset = unwrap ? 1 : 0;
+    return scriptSetup.content.substring(range.start + offset, range.end - offset);
+}
+//# sourceMappingURL=scriptSetup.js.map

node_modules/@vue/language-core/lib/codegen/script/src.d.ts

@@ -0,0 +1,2 @@
+import type { Code, Sfc } from '../../types';
+export declare function generateSrc(script: NonNullable<Sfc['script']>, src: string): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/src.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSrc = generateSrc;
+const common_1 = require("../common");
+const index_1 = require("./index");
+function* generateSrc(script, src) {
+    if (src.endsWith('.d.ts')) {
+        src = src.substring(0, src.length - '.d.ts'.length);
+    }
+    else if (src.endsWith('.ts')) {
+        src = src.substring(0, src.length - '.ts'.length);
+    }
+    else if (src.endsWith('.tsx')) {
+        src = src.substring(0, src.length - '.tsx'.length) + '.jsx';
+    }
+    if (!src.endsWith('.js') && !src.endsWith('.jsx')) {
+        src = src + '.js';
+    }
+    yield `export * from `;
+    yield [
+        `'${src}'`,
+        'script',
+        script.srcOffset - 1,
+        {
+            ...index_1.codeFeatures.all,
+            navigation: src === script.src
+                ? true
+                : {
+                    shouldRename: () => false,
+                    resolveRenameEditText(newName) {
+                        if (newName.endsWith('.jsx') || newName.endsWith('.js')) {
+                            newName = newName.split('.').slice(0, -1).join('.');
+                        }
+                        if (script?.src?.endsWith('.d.ts')) {
+                            newName = newName + '.d.ts';
+                        }
+                        else if (script?.src?.endsWith('.ts')) {
+                            newName = newName + '.ts';
+                        }
+                        else if (script?.src?.endsWith('.tsx')) {
+                            newName = newName + '.tsx';
+                        }
+                        return newName;
+                    },
+                },
+        },
+    ];
+    yield common_1.endOfLine;
+    yield `export { default } from '${src}'${common_1.endOfLine}`;
+}
+//# sourceMappingURL=src.js.map

node_modules/@vue/language-core/lib/codegen/script/styleModulesType.d.ts

@@ -0,0 +1,4 @@
+import type { Code } from '../../types';
+import type { ScriptCodegenContext } from './context';
+import { ScriptCodegenOptions } from './index';
+export declare function generateStyleModulesType(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/script/styleModulesType.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStyleModulesType = generateStyleModulesType;
+const index_1 = require("./index");
+const template_1 = require("./template");
+const common_1 = require("../common");
+function* generateStyleModulesType(options, ctx) {
+    const styles = options.sfc.styles.map((style, i) => [style, i]).filter(([style]) => style.module);
+    if (!styles.length && !options.scriptSetupRanges?.cssModules.length) {
+        return;
+    }
+    yield `type __VLS_StyleModules = {${common_1.newLine}`;
+    for (const [style, i] of styles) {
+        const { name, offset } = style.module;
+        if (offset) {
+            yield [
+                name,
+                'main',
+                offset + 1,
+                index_1.codeFeatures.all
+            ];
+        }
+        else {
+            yield name;
+        }
+        yield `: Record<string, string> & ${ctx.localTypes.PrettifyLocal}<{}`;
+        for (const className of style.classNames) {
+            yield* (0, template_1.generateCssClassProperty)(i, className.text, className.offset, 'string', false);
+        }
+        yield `>${common_1.endOfLine}`;
+    }
+    yield `}${common_1.endOfLine}`;
+}
+//# sourceMappingURL=styleModulesType.js.map

node_modules/@vue/language-core/lib/codegen/script/template.d.ts

@@ -0,0 +1,8 @@
+import type { Code } from '../../types';
+import { TemplateCodegenContext } from '../template/context';
+import type { ScriptCodegenContext } from './context';
+import { type ScriptCodegenOptions } from './index';
+export declare function generateTemplateDirectives(options: ScriptCodegenOptions): Generator<Code>;
+export declare function generateTemplate(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Generator<Code, TemplateCodegenContext>;
+export declare function generateCssClassProperty(styleIndex: number, classNameWithDot: string, offset: number, propertyType: string, optional: boolean): Generator<Code>;
+export declare function getTemplateUsageVars(options: ScriptCodegenOptions, ctx: ScriptCodegenContext): Set<string>;

node_modules/@vue/language-core/lib/codegen/script/template.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTemplateDirectives = generateTemplateDirectives;
+exports.generateTemplate = generateTemplate;
+exports.generateCssClassProperty = generateCssClassProperty;
+exports.getTemplateUsageVars = getTemplateUsageVars;
+const path = require("path-browserify");
+const shared_1 = require("../../utils/shared");
+const common_1 = require("../common");
+const context_1 = require("../template/context");
+const interpolation_1 = require("../template/interpolation");
+const styleScopedClasses_1 = require("../template/styleScopedClasses");
+const index_1 = require("./index");
+function* generateTemplateCtx(options) {
+    const exps = [];
+    exps.push(`{} as InstanceType<__VLS_PickNotAny<typeof __VLS_self, new () => {}>>`);
+    if (options.vueCompilerOptions.petiteVueExtensions.some(ext => options.fileName.endsWith(ext))) {
+        exps.push(`globalThis`);
+    }
+    if (options.sfc.styles.some(style => style.module)) {
+        exps.push(`{} as __VLS_StyleModules`);
+    }
+    yield `const __VLS_ctx = `;
+    if (exps.length === 1) {
+        yield exps[0];
+        yield `${common_1.endOfLine}`;
+    }
+    else {
+        yield `{${common_1.newLine}`;
+        for (const exp of exps) {
+            yield `...`;
+            yield exp;
+            yield `,${common_1.newLine}`;
+        }
+        yield `}${common_1.endOfLine}`;
+    }
+}
+function* generateTemplateComponents(options) {
+    const exps = [];
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.componentsOption) {
+        const { componentsOption } = options.scriptRanges.exportDefault;
+        exps.push([
+            options.sfc.script.content.substring(componentsOption.start, componentsOption.end),
+            'script',
+            componentsOption.start,
+            index_1.codeFeatures.navigation,
+        ]);
+    }
+    let nameType;
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.nameOption) {
+        const { nameOption } = options.scriptRanges.exportDefault;
+        nameType = options.sfc.script.content.substring(nameOption.start, nameOption.end);
+    }
+    else if (options.sfc.scriptSetup) {
+        const baseName = path.basename(options.fileName);
+        nameType = `'${options.scriptSetupRanges?.options.name ?? baseName.substring(0, baseName.lastIndexOf('.'))}'`;
+    }
+    if (nameType) {
+        exps.push(`{} as {
+			[K in ${nameType}]: typeof __VLS_self
+				& (new () => {
+					${(0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target)}: typeof ${options.scriptSetupRanges?.slots?.name ?? '__VLS_slots'}
+				})
+		}`);
+    }
+    exps.push(`{} as NonNullable<typeof __VLS_self extends { components: infer C } ? C : {}>`);
+    exps.push(`__VLS_ctx`);
+    yield `const __VLS_localComponents = {${common_1.newLine}`;
+    for (const type of exps) {
+        yield `...`;
+        yield type;
+        yield `,${common_1.newLine}`;
+    }
+    yield `}${common_1.endOfLine}`;
+    yield `let __VLS_components!: typeof __VLS_localComponents & __VLS_GlobalComponents${common_1.endOfLine}`;
+}
+function* generateTemplateDirectives(options) {
+    const exps = [];
+    if (options.sfc.script && options.scriptRanges?.exportDefault?.directivesOption) {
+        const { directivesOption } = options.scriptRanges.exportDefault;
+        exps.push([
+            options.sfc.script.content.substring(directivesOption.start, directivesOption.end),
+            'script',
+            directivesOption.start,
+            index_1.codeFeatures.navigation,
+        ]);
+    }
+    exps.push(`{} as NonNullable<typeof __VLS_self extends { directives: infer D } ? D : {}>`);
+    exps.push(`__VLS_ctx`);
+    yield `const __VLS_localDirectives = {${common_1.newLine}`;
+    for (const type of exps) {
+        yield `...`;
+        yield type;
+        yield `,${common_1.newLine}`;
+    }
+    yield `}${common_1.endOfLine}`;
+    yield `let __VLS_directives!: typeof __VLS_localDirectives & __VLS_GlobalDirectives${common_1.endOfLine}`;
+}
+function* generateTemplate(options, ctx) {
+    ctx.generatedTemplate = true;
+    const templateCodegenCtx = (0, context_1.createTemplateCodegenContext)({
+        scriptSetupBindingNames: new Set(),
+        edited: options.edited,
+    });
+    yield* generateTemplateCtx(options);
+    yield* generateTemplateComponents(options);
+    yield* generateTemplateDirectives(options);
+    yield* generateTemplateBody(options, templateCodegenCtx);
+    return templateCodegenCtx;
+}
+function* generateTemplateBody(options, templateCodegenCtx) {
+    const firstClasses = new Set();
+    yield `let __VLS_styleScopedClasses!: {}`;
+    for (let i = 0; i < options.sfc.styles.length; i++) {
+        const style = options.sfc.styles[i];
+        const option = options.vueCompilerOptions.experimentalResolveStyleCssClasses;
+        if (option === 'always' || (option === 'scoped' && style.scoped)) {
+            for (const className of style.classNames) {
+                if (firstClasses.has(className.text)) {
+                    templateCodegenCtx.scopedClasses.push({
+                        source: 'style_' + i,
+                        className: className.text.slice(1),
+                        offset: className.offset + 1
+                    });
+                    continue;
+                }
+                firstClasses.add(className.text);
+                yield* generateCssClassProperty(i, className.text, className.offset, 'boolean', true);
+            }
+        }
+    }
+    yield common_1.endOfLine;
+    yield* (0, styleScopedClasses_1.generateStyleScopedClasses)(templateCodegenCtx, true);
+    yield* generateCssVars(options, templateCodegenCtx);
+    if (options.templateCodegen) {
+        for (const code of options.templateCodegen.codes) {
+            yield code;
+        }
+    }
+    else {
+        yield `// no template${common_1.newLine}`;
+        if (!options.scriptSetupRanges?.slots.define) {
+            yield `const __VLS_slots = {}${common_1.endOfLine}`;
+        }
+        yield `const __VLS_inheritedAttrs = {}${common_1.endOfLine}`;
+        yield `const $refs = {}${common_1.endOfLine}`;
+        yield `const $el = {} as any${common_1.endOfLine}`;
+    }
+    yield `return {${common_1.newLine}`;
+    yield `	attrs: {} as Partial<typeof __VLS_inheritedAttrs>,${common_1.newLine}`;
+    yield `	slots: ${options.scriptSetupRanges?.slots.name ?? '__VLS_slots'},${common_1.newLine}`;
+    yield `	refs: $refs,${common_1.newLine}`;
+    yield `	rootEl: $el,${common_1.newLine}`;
+    yield `}${common_1.endOfLine}`;
+}
+function* generateCssClassProperty(styleIndex, classNameWithDot, offset, propertyType, optional) {
+    yield `${common_1.newLine} & { `;
+    yield [
+        '',
+        'style_' + styleIndex,
+        offset,
+        index_1.codeFeatures.navigation,
+    ];
+    yield `'`;
+    yield [
+        classNameWithDot.substring(1),
+        'style_' + styleIndex,
+        offset + 1,
+        index_1.codeFeatures.navigation,
+    ];
+    yield `'`;
+    yield [
+        '',
+        'style_' + styleIndex,
+        offset + classNameWithDot.length,
+        index_1.codeFeatures.navigationWithoutRename,
+    ];
+    yield `${optional ? '?' : ''}: ${propertyType}`;
+    yield ` }`;
+}
+function* generateCssVars(options, ctx) {
+    if (!options.sfc.styles.length) {
+        return;
+    }
+    yield `// CSS variable injection ${common_1.newLine}`;
+    for (const style of options.sfc.styles) {
+        for (const cssBind of style.cssVars) {
+            for (const [segment, offset, onlyError] of (0, interpolation_1.forEachInterpolationSegment)(options.ts, undefined, undefined, ctx, cssBind.text, cssBind.offset, options.ts.createSourceFile('/a.txt', cssBind.text, 99))) {
+                if (offset === undefined) {
+                    yield segment;
+                }
+                else {
+                    yield [
+                        segment,
+                        style.name,
+                        cssBind.offset + offset,
+                        onlyError
+                            ? index_1.codeFeatures.navigation
+                            : index_1.codeFeatures.all,
+                    ];
+                }
+            }
+            yield common_1.endOfLine;
+        }
+    }
+    yield `// CSS variable injection end ${common_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.indexOf('.') >= 0) {
+                usageVars.add(component.split('.')[0]);
+            }
+        }
+        for (const [varName] of options.templateCodegen.accessExternalVariables) {
+            usageVars.add(varName);
+        }
+    }
+    return usageVars;
+}
+//# sourceMappingURL=template.js.map

node_modules/@vue/language-core/lib/codegen/template/camelized.d.ts

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from '../../types';
+export declare function generateCamelized(code: string, offset: number, info: VueCodeInformation): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/camelized.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCamelized = generateCamelized;
+const shared_1 = require("@vue/shared");
+const common_1 = require("../common");
+function* generateCamelized(code, offset, info) {
+    const parts = code.split('-');
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part !== '') {
+            if (i === 0) {
+                yield [
+                    part,
+                    'template',
+                    offset,
+                    info,
+                ];
+            }
+            else {
+                yield [
+                    (0, shared_1.capitalize)(part),
+                    'template',
+                    offset,
+                    common_1.combineLastMapping,
+                ];
+            }
+        }
+        offset += part.length + 1;
+    }
+}
+//# sourceMappingURL=camelized.js.map

node_modules/@vue/language-core/lib/codegen/template/context.d.ts

@@ -0,0 +1,56 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+import type { Code, VueCodeInformation } from '../../types';
+import type { TemplateCodegenOptions } from './index';
+import { InlayHintInfo } from '../inlayHints';
+export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
+export declare function createTemplateCodegenContext(options: Pick<TemplateCodegenOptions, 'scriptSetupBindingNames' | 'edited'>): {
+    slots: {
+        name: string;
+        loc?: number;
+        tagRange: [number, number];
+        varName: string;
+        nodeLoc: any;
+    }[];
+    dynamicSlots: {
+        expVar: string;
+        varName: string;
+    }[];
+    codeFeatures: {
+        all: VueCodeInformation;
+        verification: VueCodeInformation;
+        completion: VueCodeInformation;
+        additionalCompletion: VueCodeInformation;
+        navigation: VueCodeInformation;
+        navigationWithoutRename: VueCodeInformation;
+        navigationAndCompletion: VueCodeInformation;
+        navigationAndAdditionalCompletion: VueCodeInformation;
+        withoutHighlight: VueCodeInformation;
+        withoutHighlightAndCompletion: VueCodeInformation;
+        withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
+    };
+    accessExternalVariables: Map<string, Set<number>>;
+    hasSlotElements: Set<CompilerDOM.ElementNode>;
+    blockConditions: string[];
+    usedComponentCtxVars: Set<string>;
+    scopedClasses: {
+        source: string;
+        className: string;
+        offset: number;
+    }[];
+    emptyClassOffsets: number[];
+    inlayHints: InlayHintInfo[];
+    hasSlot: boolean;
+    inheritedAttrVars: Set<unknown>;
+    templateRefs: Map<string, [varName: string, offset: number]>;
+    singleRootElType: string | undefined;
+    singleRootNode: CompilerDOM.ElementNode | undefined;
+    accessExternalVariable(name: string, offset?: number): void;
+    hasLocalVariable: (name: string) => boolean;
+    addLocalVariable: (name: string) => void;
+    removeLocalVariable: (name: string) => void;
+    getInternalVariable: () => string;
+    ignoreError: () => Generator<Code>;
+    expectError: (prevNode: CompilerDOM.CommentNode) => Generator<Code>;
+    resetDirectiveComments: (endStr: string) => Generator<Code>;
+    generateAutoImportCompletion: () => Generator<Code>;
+};

node_modules/@vue/language-core/lib/codegen/template/context.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTemplateCodegenContext = createTemplateCodegenContext;
+const common_1 = require("../common");
+const _codeFeatures = {
+    all: {
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+    },
+    verification: {
+        verification: true,
+    },
+    completion: {
+        completion: true,
+    },
+    additionalCompletion: {
+        completion: { isAdditional: true },
+    },
+    navigation: {
+        navigation: true,
+    },
+    navigationWithoutRename: {
+        navigation: {
+            shouldRename() {
+                return false;
+            },
+        },
+    },
+    navigationAndCompletion: {
+        navigation: true,
+        completion: true,
+    },
+    navigationAndAdditionalCompletion: {
+        navigation: true,
+        completion: { isAdditional: true },
+    },
+    withoutHighlight: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+        completion: true,
+    },
+    withoutHighlightAndCompletion: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+    },
+    withoutHighlightAndCompletionAndNavigation: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+    },
+};
+function createTemplateCodegenContext(options) {
+    let ignoredError = false;
+    let expectErrorToken;
+    let variableId = 0;
+    const codeFeatures = new Proxy(_codeFeatures, {
+        get(target, key) {
+            const data = target[key];
+            if (data.verification) {
+                if (ignoredError) {
+                    return {
+                        ...data,
+                        verification: false,
+                    };
+                }
+                if (expectErrorToken) {
+                    const token = expectErrorToken;
+                    if (typeof data.verification !== 'object' || !data.verification.shouldReport) {
+                        return {
+                            ...data,
+                            verification: {
+                                shouldReport: () => {
+                                    token.errors++;
+                                    return false;
+                                },
+                            },
+                        };
+                    }
+                }
+            }
+            return data;
+        },
+    });
+    const localVars = new Map();
+    const accessExternalVariables = new Map();
+    const slots = [];
+    const dynamicSlots = [];
+    const hasSlotElements = new Set();
+    ;
+    const blockConditions = [];
+    const usedComponentCtxVars = new Set();
+    const scopedClasses = [];
+    const emptyClassOffsets = [];
+    const inlayHints = [];
+    const templateRefs = new Map();
+    return {
+        slots,
+        dynamicSlots,
+        codeFeatures,
+        accessExternalVariables,
+        hasSlotElements,
+        blockConditions,
+        usedComponentCtxVars,
+        scopedClasses,
+        emptyClassOffsets,
+        inlayHints,
+        hasSlot: false,
+        inheritedAttrVars: new Set(),
+        templateRefs,
+        singleRootElType: undefined,
+        singleRootNode: undefined,
+        accessExternalVariable(name, offset) {
+            let arr = accessExternalVariables.get(name);
+            if (!arr) {
+                accessExternalVariables.set(name, arr = new Set());
+            }
+            if (offset !== undefined) {
+                arr.add(offset);
+            }
+        },
+        hasLocalVariable: (name) => {
+            return !!localVars.get(name);
+        },
+        addLocalVariable: (name) => {
+            localVars.set(name, (localVars.get(name) ?? 0) + 1);
+        },
+        removeLocalVariable: (name) => {
+            localVars.set(name, localVars.get(name) - 1);
+        },
+        getInternalVariable: () => {
+            return `__VLS_${variableId++}`;
+        },
+        ignoreError: function* () {
+            if (!ignoredError) {
+                ignoredError = true;
+                yield `// @vue-ignore start${common_1.newLine}`;
+            }
+        },
+        expectError: function* (prevNode) {
+            if (!expectErrorToken) {
+                expectErrorToken = {
+                    errors: 0,
+                    node: prevNode,
+                };
+                yield `// @vue-expect-error start${common_1.newLine}`;
+            }
+        },
+        resetDirectiveComments: function* (endStr) {
+            if (expectErrorToken) {
+                const token = expectErrorToken;
+                yield* (0, common_1.wrapWith)(expectErrorToken.node.loc.start.offset, expectErrorToken.node.loc.end.offset, {
+                    verification: {
+                        shouldReport: () => token.errors === 0,
+                    },
+                }, `// @ts-expect-error __VLS_TS_EXPECT_ERROR`);
+                yield `${common_1.newLine}${common_1.endOfLine}`;
+                expectErrorToken = undefined;
+                yield `// @vue-expect-error ${endStr}${common_1.newLine}`;
+            }
+            if (ignoredError) {
+                ignoredError = false;
+                yield `// @vue-ignore ${endStr}${common_1.newLine}`;
+            }
+        },
+        generateAutoImportCompletion: function* () {
+            if (!options.edited) {
+                return;
+            }
+            const all = [...accessExternalVariables.entries()];
+            if (!all.some(([_, offsets]) => offsets.size)) {
+                return;
+            }
+            yield `// @ts-ignore${common_1.newLine}`; // #2304
+            yield `[`;
+            for (const [varName, offsets] of all) {
+                for (const offset of offsets) {
+                    if (options.scriptSetupBindingNames.has(varName)) {
+                        // #3409
+                        yield [
+                            varName,
+                            'template',
+                            offset,
+                            {
+                                ...codeFeatures.additionalCompletion,
+                                ...codeFeatures.withoutHighlightAndCompletionAndNavigation,
+                            },
+                        ];
+                    }
+                    else {
+                        yield [
+                            varName,
+                            'template',
+                            offset,
+                            codeFeatures.additionalCompletion,
+                        ];
+                    }
+                    yield `,`;
+                }
+                offsets.clear();
+            }
+            yield `]${common_1.endOfLine}`;
+        }
+    };
+}
+//# sourceMappingURL=context.js.map

node_modules/@vue/language-core/lib/codegen/template/element.d.ts

@@ -0,0 +1,8 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateComponent(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, currentComponent: CompilerDOM.ElementNode | undefined): Generator<Code>;
+export declare function generateElement(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined, isVForChild: boolean): Generator<Code>;
+export declare function getCanonicalComponentName(tagText: string): string;
+export declare function getPossibleOriginalComponentNames(tagText: string, deduplicate: boolean): string[];

node_modules/@vue/language-core/lib/codegen/template/element.js

@@ -0,0 +1,544 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateComponent = generateComponent;
+exports.generateElement = generateElement;
+exports.getCanonicalComponentName = getCanonicalComponentName;
+exports.getPossibleOriginalComponentNames = getPossibleOriginalComponentNames;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const shared_2 = require("../../utils/shared");
+const common_1 = require("../common");
+const camelized_1 = require("./camelized");
+const elementChildren_1 = require("./elementChildren");
+const elementDirectives_1 = require("./elementDirectives");
+const elementEvents_1 = require("./elementEvents");
+const elementProps_1 = require("./elementProps");
+const interpolation_1 = require("./interpolation");
+const propertyAccess_1 = require("./propertyAccess");
+const templateChild_1 = require("./templateChild");
+const objectProperty_1 = require("./objectProperty");
+const inlayHints_1 = require("../inlayHints");
+const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
+const colonReg = /:/g;
+function* generateComponent(options, ctx, node, currentComponent) {
+    const startTagOffset = node.loc.start.offset + options.template.content.substring(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 tagOffsets = endTagOffset !== undefined && endTagOffset > startTagOffset
+        ? [startTagOffset, endTagOffset]
+        : [startTagOffset];
+    const propsFailedExps = [];
+    const possibleOriginalNames = getPossibleOriginalComponentNames(node.tag, true);
+    const matchImportName = possibleOriginalNames.find(name => options.scriptSetupImportComponentNames.has(name));
+    const var_originalComponent = matchImportName ?? ctx.getInternalVariable();
+    const var_functionalComponent = ctx.getInternalVariable();
+    const var_componentInstance = ctx.getInternalVariable();
+    const var_componentEmit = ctx.getInternalVariable();
+    const var_componentEvents = ctx.getInternalVariable();
+    const var_defineComponentCtx = ctx.getInternalVariable();
+    const isComponentTag = node.tag.toLowerCase() === 'component';
+    let props = node.props;
+    let dynamicTagInfo;
+    if (isComponentTag) {
+        for (const prop of node.props) {
+            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+                && prop.name === 'bind'
+                && prop.arg?.loc.source === 'is'
+                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                if (prop.arg.loc.end.offset === prop.exp.loc.end.offset) {
+                    ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(prop.exp.loc, 'is'));
+                }
+                dynamicTagInfo = {
+                    tag: prop.exp.content,
+                    offsets: [prop.exp.loc.start.offset, undefined],
+                    astHolder: prop.exp.loc,
+                };
+                props = props.filter(p => p !== prop);
+                break;
+            }
+        }
+    }
+    else if (node.tag.includes('.')) {
+        // namespace tag
+        dynamicTagInfo = {
+            tag: node.tag,
+            offsets: [startTagOffset, endTagOffset],
+            astHolder: node.loc,
+        };
+    }
+    if (matchImportName) {
+        // hover, renaming / find references support
+        yield `// @ts-ignore${common_1.newLine}`; // #2304
+        yield `[`;
+        for (const tagOffset of tagOffsets) {
+            if (var_originalComponent === node.tag) {
+                yield [
+                    var_originalComponent,
+                    'template',
+                    tagOffset,
+                    ctx.codeFeatures.withoutHighlightAndCompletion,
+                ];
+            }
+            else {
+                yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(node.tag), tagOffset, {
+                    ...ctx.codeFeatures.withoutHighlightAndCompletion,
+                    navigation: {
+                        resolveRenameNewName: camelizeComponentName,
+                        resolveRenameEditText: getTagRenameApply(node.tag),
+                    },
+                });
+            }
+            yield `,`;
+        }
+        yield `]${common_1.endOfLine}`;
+    }
+    else if (dynamicTagInfo) {
+        yield `const ${var_originalComponent} = (`;
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, dynamicTagInfo.tag, dynamicTagInfo.astHolder, dynamicTagInfo.offsets[0], ctx.codeFeatures.all, '(', ')');
+        if (dynamicTagInfo.offsets[1] !== undefined) {
+            yield `,`;
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, dynamicTagInfo.tag, dynamicTagInfo.astHolder, dynamicTagInfo.offsets[1], {
+                ...ctx.codeFeatures.all,
+                completion: false,
+            }, '(', ')');
+        }
+        yield `)${common_1.endOfLine}`;
+    }
+    else if (!isComponentTag) {
+        yield `const ${var_originalComponent} = __VLS_resolvedLocalAndGlobalComponents.`;
+        yield* generateCanonicalComponentName(node.tag, startTagOffset, {
+            // with hover support
+            ...ctx.codeFeatures.withoutHighlightAndCompletionAndNavigation,
+            ...ctx.codeFeatures.verification,
+        });
+        yield `${common_1.endOfLine}`;
+        const camelizedTag = (0, shared_1.camelize)(node.tag);
+        if (common_1.variableNameRegex.test(camelizedTag)) {
+            // renaming / find references support
+            yield `/** @type { [`;
+            for (const tagOffset of tagOffsets) {
+                for (const shouldCapitalize of (node.tag[0] === node.tag[0].toUpperCase() ? [false] : [true, false])) {
+                    const expectName = shouldCapitalize ? (0, shared_1.capitalize)(camelizedTag) : camelizedTag;
+                    yield `typeof __VLS_components.`;
+                    yield* (0, camelized_1.generateCamelized)(shouldCapitalize ? (0, shared_1.capitalize)(node.tag) : node.tag, tagOffset, {
+                        navigation: {
+                            resolveRenameNewName: node.tag !== expectName ? camelizeComponentName : undefined,
+                            resolveRenameEditText: getTagRenameApply(node.tag),
+                        },
+                    });
+                    yield `, `;
+                }
+            }
+            yield `] } */${common_1.newLine}`;
+            // auto import support
+            if (options.edited) {
+                yield `// @ts-ignore${common_1.newLine}`; // #2304
+                yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(node.tag), startTagOffset, {
+                    completion: {
+                        isAdditional: true,
+                        onlyImport: true,
+                    },
+                });
+                yield `${common_1.endOfLine}`;
+            }
+        }
+    }
+    else {
+        yield `const ${var_originalComponent} = {} as any${common_1.endOfLine}`;
+    }
+    yield `// @ts-ignore${common_1.newLine}`;
+    yield `const ${var_functionalComponent} = __VLS_asFunctionalComponent(${var_originalComponent}, new ${var_originalComponent}({`;
+    yield* (0, elementProps_1.generateElementProps)(options, ctx, node, props, false);
+    yield `}))${common_1.endOfLine}`;
+    yield `const ${var_componentInstance} = ${var_functionalComponent}(`;
+    yield* (0, common_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, props, true, propsFailedExps), `}`);
+    yield `, ...__VLS_functionalComponentArgsRest(${var_functionalComponent}))${common_1.endOfLine}`;
+    currentComponent = node;
+    for (const failedExp of propsFailedExps) {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, failedExp.node.loc.source, failedExp.node.loc, failedExp.node.loc.start.offset, ctx.codeFeatures.all, failedExp.prefix, failedExp.suffix);
+        yield common_1.endOfLine;
+    }
+    const [refName, offset] = yield* generateVScope(options, ctx, node, props);
+    const isRootNode = node === ctx.singleRootNode;
+    if (refName || isRootNode) {
+        const varName = ctx.getInternalVariable();
+        ctx.usedComponentCtxVars.add(var_defineComponentCtx);
+        yield `var ${varName} = {} as (Parameters<NonNullable<typeof ${var_defineComponentCtx}['expose']>>[0] | null)`;
+        if (node.codegenNode?.type === CompilerDOM.NodeTypes.VNODE_CALL
+            && node.codegenNode.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION
+            && node.codegenNode.props.properties.some(({ key }) => key.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && key.content === 'ref_for')) {
+            yield `[]`;
+        }
+        yield `${common_1.endOfLine}`;
+        if (refName) {
+            ctx.templateRefs.set(refName, [varName, offset]);
+        }
+        if (isRootNode) {
+            ctx.singleRootElType = `NonNullable<typeof ${varName}>['$el']`;
+        }
+    }
+    const usedComponentEventsVar = yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, var_functionalComponent, var_componentInstance, var_componentEmit, var_componentEvents);
+    if (usedComponentEventsVar) {
+        ctx.usedComponentCtxVars.add(var_defineComponentCtx);
+        yield `let ${var_componentEmit}!: typeof ${var_defineComponentCtx}.emit${common_1.endOfLine}`;
+        yield `let ${var_componentEvents}!: __VLS_NormalizeEmits<typeof ${var_componentEmit}>${common_1.endOfLine}`;
+    }
+    if (options.vueCompilerOptions.fallthroughAttributes
+        && (node.props.some(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && prop.name === 'bind' && prop.exp?.loc.source === '$attrs')
+            || node === ctx.singleRootNode)) {
+        const varAttrs = ctx.getInternalVariable();
+        ctx.inheritedAttrVars.add(varAttrs);
+        yield `var ${varAttrs}!: Parameters<typeof ${var_functionalComponent}>[0];\n`;
+    }
+    const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
+    if (slotDir) {
+        yield* generateComponentSlot(options, ctx, node, slotDir, currentComponent, var_defineComponentCtx);
+    }
+    else {
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentComponent, var_defineComponentCtx);
+    }
+    if (ctx.usedComponentCtxVars.has(var_defineComponentCtx)) {
+        yield `var ${var_defineComponentCtx}!: __VLS_PickFunctionalComponentCtx<typeof ${var_originalComponent}, typeof ${var_componentInstance}>${common_1.endOfLine}`;
+    }
+}
+function* generateElement(options, ctx, node, currentComponent, componentCtxVar, isVForChild) {
+    const startTagOffset = node.loc.start.offset + options.template.content.substring(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 propsFailedExps = [];
+    yield `__VLS_elementAsFunction(__VLS_intrinsicElements`;
+    yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, startTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
+    if (endTagOffset !== undefined) {
+        yield `, __VLS_intrinsicElements`;
+        yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, endTagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
+    }
+    yield `)(`;
+    yield* (0, common_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props, true, propsFailedExps), `}`);
+    yield `)${common_1.endOfLine}`;
+    for (const failedExp of propsFailedExps) {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, failedExp.node.loc.source, failedExp.node.loc, failedExp.node.loc.start.offset, ctx.codeFeatures.all, failedExp.prefix, failedExp.suffix);
+        yield common_1.endOfLine;
+    }
+    const [refName, offset] = yield* generateVScope(options, ctx, node, node.props);
+    if (refName) {
+        let refValue = `__VLS_nativeElements['${node.tag}']`;
+        if (isVForChild) {
+            refValue = `[${refValue}]`;
+        }
+        ctx.templateRefs.set(refName, [refValue, offset]);
+    }
+    if (ctx.singleRootNode === node) {
+        ctx.singleRootElType = `typeof __VLS_nativeElements['${node.tag}']`;
+    }
+    const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
+    if (slotDir && componentCtxVar) {
+        yield* generateComponentSlot(options, ctx, node, slotDir, currentComponent, componentCtxVar);
+    }
+    else {
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentComponent, componentCtxVar);
+    }
+    if (options.vueCompilerOptions.fallthroughAttributes
+        && (node.props.some(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && prop.name === 'bind' && prop.exp?.loc.source === '$attrs')
+            || node === ctx.singleRootNode)) {
+        ctx.inheritedAttrVars.add(`__VLS_intrinsicElements.${node.tag}`);
+    }
+}
+function* generateVScope(options, ctx, node, props) {
+    const vScope = props.find(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && (prop.name === 'scope' || prop.name === 'data'));
+    let inScope = false;
+    let originalConditionsNum = ctx.blockConditions.length;
+    if (vScope?.type === CompilerDOM.NodeTypes.DIRECTIVE && vScope.exp) {
+        const scopeVar = ctx.getInternalVariable();
+        const condition = `__VLS_withScope(__VLS_ctx, ${scopeVar})`;
+        yield `const ${scopeVar} = `;
+        yield [
+            vScope.exp.loc.source,
+            'template',
+            vScope.exp.loc.start.offset,
+            ctx.codeFeatures.all,
+        ];
+        yield common_1.endOfLine;
+        yield `if (${condition}) {${common_1.newLine}`;
+        ctx.blockConditions.push(condition);
+        inScope = true;
+    }
+    yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
+    const [refName, offset] = yield* generateReferencesForElements(options, ctx, node); // <el ref="foo" />
+    yield* generateReferencesForScopedCssClasses(options, ctx, node);
+    if (inScope) {
+        yield `}${common_1.newLine}`;
+        ctx.blockConditions.length = originalConditionsNum;
+    }
+    return [refName, offset];
+}
+function getCanonicalComponentName(tagText) {
+    return common_1.variableNameRegex.test(tagText)
+        ? tagText
+        : (0, shared_1.capitalize)((0, shared_1.camelize)(tagText.replace(colonReg, '-')));
+}
+function getPossibleOriginalComponentNames(tagText, deduplicate) {
+    const name1 = (0, shared_1.capitalize)((0, shared_1.camelize)(tagText));
+    const name2 = (0, shared_1.camelize)(tagText);
+    const name3 = tagText;
+    const names = [name1];
+    if (!deduplicate || name2 !== name1) {
+        names.push(name2);
+    }
+    if (!deduplicate || name3 !== name2) {
+        names.push(name3);
+    }
+    return names;
+}
+function* generateCanonicalComponentName(tagText, offset, features) {
+    if (common_1.variableNameRegex.test(tagText)) {
+        yield [tagText, 'template', offset, features];
+    }
+    else {
+        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(tagText.replace(colonReg, '-')), offset, features);
+    }
+}
+function* generateComponentSlot(options, ctx, node, slotDir, currentComponent, componentCtxVar) {
+    yield `{${common_1.newLine}`;
+    ctx.usedComponentCtxVars.add(componentCtxVar);
+    if (currentComponent) {
+        ctx.hasSlotElements.add(currentComponent);
+    }
+    const slotBlockVars = [];
+    yield `const {`;
+    if (slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
+        yield ': __VLS_thisSlot';
+    }
+    else {
+        yield `default: `;
+        yield* (0, common_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+            ? '#'.length
+            : slotDir.loc.source.startsWith('v-slot:')
+                ? 'v-slot:'.length
+                : 0), ctx.codeFeatures.withoutHighlightAndCompletion, `__VLS_thisSlot`);
+    }
+    yield `} = __VLS_nonNullable(${componentCtxVar}.slots)${common_1.endOfLine}`;
+    if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        const slotAst = (0, common_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
+        (0, common_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
+        if (!slotDir.exp.content.includes(':')) {
+            yield `const [`;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield `] = __VLS_getSlotParams(__VLS_thisSlot)${common_1.endOfLine}`;
+        }
+        else {
+            yield `const `;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield ` = __VLS_getSlotParam(__VLS_thisSlot)${common_1.endOfLine}`;
+        }
+    }
+    for (const varName of slotBlockVars) {
+        ctx.addLocalVariable(varName);
+    }
+    yield* ctx.resetDirectiveComments('end of slot children start');
+    let prev;
+    for (const childNode of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+        prev = childNode;
+    }
+    for (const varName of slotBlockVars) {
+        ctx.removeLocalVariable(varName);
+    }
+    let isStatic = true;
+    if (slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        isStatic = slotDir.arg.isStatic;
+    }
+    if (isStatic && slotDir && !slotDir.arg) {
+        yield `__VLS_nonNullable(${componentCtxVar}.slots)['`;
+        yield [
+            '',
+            'template',
+            slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+                ? '#'.length : slotDir.loc.source.startsWith('v-slot:')
+                ? 'v-slot:'.length
+                : 0),
+            ctx.codeFeatures.completion,
+        ];
+        yield `'/* empty slot name completion */]${common_1.newLine}`;
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield `}${common_1.newLine}`;
+}
+function* generateReferencesForElements(options, ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && prop.name === 'ref'
+            && prop.value) {
+            const [content, startOffset] = normalizeAttributeValue(prop.value);
+            yield `// @ts-ignore navigation for \`const ${content} = ref()\`${common_1.newLine}`;
+            yield `__VLS_ctx`;
+            yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, content, startOffset, ctx.codeFeatures.navigation, prop.value.loc);
+            yield common_1.endOfLine;
+            if (common_1.variableNameRegex.test(content)) {
+                ctx.accessExternalVariable(content, startOffset);
+            }
+            return [content, startOffset];
+        }
+    }
+    return [];
+}
+function* generateReferencesForScopedCssClasses(options, ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && prop.name === 'class'
+            && prop.value) {
+            if (options.template.lang === 'pug') {
+                const getClassOffset = Reflect.get(prop.value.loc.start, 'getClassOffset');
+                const content = prop.value.loc.source.slice(1, -1);
+                let startOffset = 1;
+                for (const className of content.split(' ')) {
+                    if (className) {
+                        ctx.scopedClasses.push({
+                            source: 'template',
+                            className,
+                            offset: getClassOffset(startOffset),
+                        });
+                    }
+                    startOffset += className.length + 1;
+                }
+            }
+            else {
+                let isWrapped = false;
+                const [content, startOffset] = normalizeAttributeValue(prop.value);
+                if (content) {
+                    const classes = collectClasses(content, startOffset + (isWrapped ? 1 : 0));
+                    ctx.scopedClasses.push(...classes);
+                }
+                else {
+                    ctx.emptyClassOffsets.push(startOffset);
+                }
+            }
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.arg.content === 'class') {
+            const content = '`${' + prop.exp.content + '}`';
+            const startOffset = prop.exp.loc.start.offset - 3;
+            const { ts } = options;
+            const ast = ts.createSourceFile('', content, 99);
+            const literals = [];
+            ts.forEachChild(ast, node => {
+                if (!ts.isExpressionStatement(node) ||
+                    !isTemplateExpression(node.expression)) {
+                    return;
+                }
+                const expression = node.expression.templateSpans[0].expression;
+                if (ts.isStringLiteralLike(expression)) {
+                    literals.push(expression);
+                }
+                if (ts.isArrayLiteralExpression(expression)) {
+                    walkArrayLiteral(expression);
+                }
+                if (ts.isObjectLiteralExpression(expression)) {
+                    walkObjectLiteral(expression);
+                }
+            });
+            for (const literal of literals) {
+                const classes = collectClasses(literal.text, literal.end - literal.text.length - 1 + startOffset);
+                ctx.scopedClasses.push(...classes);
+            }
+            function walkArrayLiteral(node) {
+                const { elements } = node;
+                for (const element of elements) {
+                    if (ts.isStringLiteralLike(element)) {
+                        literals.push(element);
+                    }
+                    else if (ts.isObjectLiteralExpression(element)) {
+                        walkObjectLiteral(element);
+                    }
+                }
+            }
+            function walkObjectLiteral(node) {
+                const { properties } = node;
+                for (const property of properties) {
+                    if (ts.isPropertyAssignment(property)) {
+                        const { name } = property;
+                        if (ts.isIdentifier(name)) {
+                            walkIdentifier(name);
+                        }
+                        else if (ts.isStringLiteral(name)) {
+                            literals.push(name);
+                        }
+                        else if (ts.isComputedPropertyName(name)) {
+                            const { expression } = name;
+                            if (ts.isStringLiteralLike(expression)) {
+                                literals.push(expression);
+                            }
+                        }
+                    }
+                    else if (ts.isShorthandPropertyAssignment(property)) {
+                        walkIdentifier(property.name);
+                    }
+                }
+            }
+            function walkIdentifier(node) {
+                const text = (0, scriptSetupRanges_1.getNodeText)(ts, node, ast);
+                ctx.scopedClasses.push({
+                    source: 'template',
+                    className: text,
+                    offset: node.end - text.length + startOffset
+                });
+            }
+        }
+    }
+}
+function camelizeComponentName(newName) {
+    return (0, shared_1.camelize)('-' + newName);
+}
+function getTagRenameApply(oldName) {
+    return oldName === (0, shared_2.hyphenateTag)(oldName) ? shared_2.hyphenateTag : undefined;
+}
+function normalizeAttributeValue(node) {
+    let offset = node.loc.start.offset;
+    let content = node.loc.source;
+    if ((content.startsWith(`'`) && content.endsWith(`'`))
+        || (content.startsWith(`"`) && content.endsWith(`"`))) {
+        offset++;
+        content = content.slice(1, -1);
+    }
+    return [content, offset];
+}
+function collectClasses(content, startOffset = 0) {
+    const classes = [];
+    let currentClassName = '';
+    let offset = 0;
+    for (const char of (content + ' ')) {
+        if (char.trim() === '') {
+            if (currentClassName !== '') {
+                classes.push({
+                    source: 'template',
+                    className: currentClassName,
+                    offset: offset + startOffset
+                });
+                offset += currentClassName.length;
+                currentClassName = '';
+            }
+            offset += char.length;
+        }
+        else {
+            currentClassName += char;
+        }
+    }
+    return classes;
+}
+// isTemplateExpression is missing in tsc
+function isTemplateExpression(node) {
+    return node.kind === 228;
+}
+//# sourceMappingURL=element.js.map

node_modules/@vue/language-core/lib/codegen/template/elementChildren.d.ts

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

node_modules/@vue/language-core/lib/codegen/template/elementChildren.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementChildren = generateElementChildren;
+const CompilerDOM = require("@vue/compiler-dom");
+const common_1 = require("../common");
+const templateChild_1 = require("./templateChild");
+function* generateElementChildren(options, ctx, node, currentComponent, componentCtxVar) {
+    yield* ctx.resetDirectiveComments('end of element children start');
+    let prev;
+    for (const childNode of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+        prev = childNode;
+    }
+    yield* ctx.generateAutoImportCompletion();
+    // fix https://github.com/vuejs/language-tools/issues/932
+    if (componentCtxVar
+        && !ctx.hasSlotElements.has(node)
+        && node.children.length
+        && node.tagType !== CompilerDOM.ElementTypes.ELEMENT
+        && node.tagType !== CompilerDOM.ElementTypes.TEMPLATE) {
+        ctx.usedComponentCtxVars.add(componentCtxVar);
+        yield `__VLS_nonNullable(${componentCtxVar}.slots).`;
+        yield* (0, common_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
+        yield common_1.endOfLine;
+    }
+}
+//# sourceMappingURL=elementChildren.js.map

node_modules/@vue/language-core/lib/codegen/template/elementDirectives.d.ts

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

node_modules/@vue/language-core/lib/codegen/template/elementDirectives.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementDirectives = generateElementDirectives;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const shared_2 = require("../../utils/shared");
+const common_1 = require("../common");
+const camelized_1 = require("./camelized");
+const interpolation_1 = require("./interpolation");
+const objectProperty_1 = require("./objectProperty");
+const stringLiteralKey_1 = require("./stringLiteralKey");
+function* generateElementDirectives(options, ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type !== CompilerDOM.NodeTypes.DIRECTIVE
+            || prop.name === 'slot'
+            || prop.name === 'on'
+            || prop.name === 'model'
+            || prop.name === 'bind'
+            || prop.name === 'scope'
+            || prop.name === 'data') {
+            continue;
+        }
+        ctx.accessExternalVariable((0, shared_1.camelize)('v-' + prop.name), prop.loc.start.offset);
+        yield* (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, `__VLS_asFunctionalDirective(`, ...generateIdentifier(ctx, prop), `)(null!, { ...__VLS_directiveBindingRestFields, `, ...generateArg(options, ctx, prop), ...generateModifiers(options, ctx, prop), ...generateValue(options, ctx, prop), `}, null!, null!)`);
+        yield common_1.endOfLine;
+    }
+}
+function* generateIdentifier(ctx, prop) {
+    const rawName = 'v-' + prop.name;
+    yield* (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + rawName.length, ctx.codeFeatures.verification, `__VLS_directives.`, ...(0, camelized_1.generateCamelized)(rawName, prop.loc.start.offset, {
+        ...ctx.codeFeatures.all,
+        verification: false,
+        completion: {
+            // fix https://github.com/vuejs/language-tools/issues/1905
+            isAdditional: true,
+        },
+        navigation: {
+            resolveRenameNewName: shared_1.camelize,
+            resolveRenameEditText: getPropRenameApply(prop.name),
+        },
+    }));
+}
+function* generateArg(options, ctx, prop) {
+    const { arg } = prop;
+    if (arg?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        return;
+    }
+    const startOffset = arg.loc.start.offset + arg.loc.source.indexOf(arg.content);
+    yield* (0, common_1.wrapWith)(startOffset, startOffset + arg.content.length, ctx.codeFeatures.verification, 'arg');
+    yield ': ';
+    if (arg.isStatic) {
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, ctx.codeFeatures.withoutHighlight);
+    }
+    else {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, arg.content, arg.loc, startOffset, ctx.codeFeatures.all, '(', ')');
+    }
+    yield ', ';
+}
+function* generateModifiers(options, ctx, prop) {
+    if (options.vueCompilerOptions.target < 3.5) {
+        return;
+    }
+    yield 'modifiers: { ';
+    for (const mod of prop.modifiers) {
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, mod.content, mod.loc.start.offset, ctx.codeFeatures.withoutHighlight);
+        yield ': true, ';
+    }
+    yield '}, ';
+}
+function* generateValue(options, ctx, prop) {
+    if (prop.exp?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        return;
+    }
+    yield* (0, common_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, 'value');
+    yield ': ';
+    yield* (0, common_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, ...(0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')'));
+}
+function getPropRenameApply(oldName) {
+    return oldName === (0, shared_2.hyphenateAttr)(oldName) ? shared_2.hyphenateAttr : undefined;
+}
+//# sourceMappingURL=elementDirectives.js.map

node_modules/@vue/language-core/lib/codegen/template/elementEvents.d.ts

@@ -0,0 +1,9 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type * as ts from 'typescript';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentVar: string, componentInstanceVar: string, emitVar: string, eventsVar: string): Generator<Code>;
+export declare function generateEventArg(ctx: TemplateCodegenContext, arg: CompilerDOM.SimpleExpressionNode, enableHover: boolean): Generator<Code>;
+export declare function generateEventExpression(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode): Generator<Code>;
+export declare function isCompoundExpression(ts: typeof import('typescript'), ast: ts.SourceFile): boolean;

node_modules/@vue/language-core/lib/codegen/template/elementEvents.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementEvents = generateElementEvents;
+exports.generateEventArg = generateEventArg;
+exports.generateEventExpression = generateEventExpression;
+exports.isCompoundExpression = isCompoundExpression;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const shared_2 = require("../../utils/shared");
+const common_1 = require("../common");
+const camelized_1 = require("./camelized");
+const interpolation_1 = require("./interpolation");
+function* generateElementEvents(options, ctx, node, componentVar, componentInstanceVar, emitVar, eventsVar) {
+    let usedComponentEventsVar = false;
+    let propsVar;
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'on'
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && !prop.arg.loc.source.startsWith('[')
+            && !prop.arg.loc.source.endsWith(']')) {
+            usedComponentEventsVar = true;
+            if (!propsVar) {
+                propsVar = ctx.getInternalVariable();
+                yield `let ${propsVar}!: __VLS_FunctionalComponentProps<typeof ${componentVar}, typeof ${componentInstanceVar}>${common_1.endOfLine}`;
+            }
+            const originalPropName = (0, shared_1.camelize)('on-' + prop.arg.loc.source);
+            const originalPropNameObjectKey = common_1.variableNameRegex.test(originalPropName)
+                ? originalPropName
+                : `'${originalPropName}'`;
+            yield `const ${ctx.getInternalVariable()}: `;
+            if (!options.vueCompilerOptions.strictTemplates) {
+                yield `Record<string, unknown> & `;
+            }
+            yield `(${common_1.newLine}`;
+            yield `__VLS_IsFunction<typeof ${propsVar}, '${originalPropName}'> extends true${common_1.newLine}`;
+            yield `? typeof ${propsVar}${common_1.newLine}`;
+            yield `: __VLS_IsFunction<typeof ${eventsVar}, '${prop.arg.loc.source}'> extends true${common_1.newLine}`;
+            yield `? {${common_1.newLine}`;
+            yield `/**__VLS_emit,${emitVar},${prop.arg.loc.source}*/${common_1.newLine}`;
+            yield `${originalPropNameObjectKey}?: typeof ${eventsVar}['${prop.arg.loc.source}']${common_1.newLine}`;
+            yield `}${common_1.newLine}`;
+            if (prop.arg.loc.source !== (0, shared_1.camelize)(prop.arg.loc.source)) {
+                yield `: __VLS_IsFunction<typeof ${eventsVar}, '${(0, shared_1.camelize)(prop.arg.loc.source)}'> extends true${common_1.newLine}`;
+                yield `? {${common_1.newLine}`;
+                yield `/**__VLS_emit,${emitVar},${(0, shared_1.camelize)(prop.arg.loc.source)}*/${common_1.newLine}`;
+                yield `${originalPropNameObjectKey}?: typeof ${eventsVar}['${(0, shared_1.camelize)(prop.arg.loc.source)}']${common_1.newLine}`;
+                yield `}${common_1.newLine}`;
+            }
+            yield `: typeof ${propsVar}${common_1.newLine}`;
+            yield `) = {${common_1.newLine}`;
+            yield* generateEventArg(ctx, prop.arg, true);
+            yield `: `;
+            yield* generateEventExpression(options, ctx, prop);
+            yield `}${common_1.endOfLine}`;
+        }
+    }
+    return usedComponentEventsVar;
+}
+const eventArgFeatures = {
+    navigation: {
+        // @click-outside -> onClickOutside
+        resolveRenameNewName(newName) {
+            return (0, shared_1.camelize)('on-' + newName);
+        },
+        // onClickOutside -> @click-outside
+        resolveRenameEditText(newName) {
+            const hName = (0, shared_2.hyphenateAttr)(newName);
+            if ((0, shared_2.hyphenateAttr)(newName).startsWith('on-')) {
+                return (0, shared_1.camelize)(hName.slice('on-'.length));
+            }
+            return newName;
+        },
+    },
+};
+function* generateEventArg(ctx, arg, enableHover) {
+    const features = enableHover
+        ? {
+            ...ctx.codeFeatures.withoutHighlightAndCompletion,
+            ...eventArgFeatures,
+        }
+        : eventArgFeatures;
+    if (common_1.variableNameRegex.test((0, shared_1.camelize)(arg.loc.source))) {
+        yield ['', 'template', arg.loc.start.offset, features];
+        yield `on`;
+        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(arg.loc.source), arg.loc.start.offset, common_1.combineLastMapping);
+    }
+    else {
+        yield* (0, common_1.wrapWith)(arg.loc.start.offset, arg.loc.end.offset, features, `'`, ['', 'template', arg.loc.start.offset, common_1.combineLastMapping], 'on', ...(0, camelized_1.generateCamelized)((0, shared_1.capitalize)(arg.loc.source), arg.loc.start.offset, common_1.combineLastMapping), `'`);
+    }
+}
+function* generateEventExpression(options, ctx, prop) {
+    if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        let prefix = '(';
+        let suffix = ')';
+        let isFirstMapping = true;
+        const ast = (0, common_1.createTsAst)(options.ts, prop.exp, prop.exp.content);
+        const _isCompoundExpression = isCompoundExpression(options.ts, ast);
+        if (_isCompoundExpression) {
+            yield `(...[$event]) => {${common_1.newLine}`;
+            ctx.addLocalVariable('$event');
+            prefix = '';
+            suffix = '';
+            for (const blockCondition of ctx.blockConditions) {
+                prefix += `if (!(${blockCondition})) return${common_1.endOfLine}`;
+            }
+        }
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, offset => {
+            if (_isCompoundExpression && isFirstMapping) {
+                isFirstMapping = false;
+                ctx.inlayHints.push({
+                    blockName: 'template',
+                    offset,
+                    setting: 'vue.inlayHints.inlineHandlerLeading',
+                    label: '$event =>',
+                    paddingRight: true,
+                    tooltip: [
+                        '`$event` is a hidden parameter, you can use it in this callback.',
+                        'To hide this hint, set `vue.inlayHints.inlineHandlerLeading` to `false` in IDE settings.',
+                        '[More info](https://github.com/vuejs/language-tools/issues/2445#issuecomment-1444771420)',
+                    ].join('\n\n'),
+                });
+            }
+            return ctx.codeFeatures.all;
+        }, prefix, suffix);
+        if (_isCompoundExpression) {
+            ctx.removeLocalVariable('$event');
+            yield common_1.endOfLine;
+            yield* ctx.generateAutoImportCompletion();
+            yield `}`;
+        }
+    }
+    else {
+        yield `() => {}`;
+    }
+}
+function isCompoundExpression(ts, ast) {
+    let result = true;
+    if (ast.statements.length === 0) {
+        result = false;
+    }
+    else if (ast.statements.length === 1) {
+        ts.forEachChild(ast, child_1 => {
+            if (ts.isExpressionStatement(child_1)) {
+                ts.forEachChild(child_1, child_2 => {
+                    if (ts.isArrowFunction(child_2)) {
+                        result = false;
+                    }
+                    else if (isPropertyAccessOrId(ts, child_2)) {
+                        result = false;
+                    }
+                });
+            }
+            else if (ts.isFunctionDeclaration(child_1)) {
+                result = false;
+            }
+        });
+    }
+    return result;
+}
+function isPropertyAccessOrId(ts, node) {
+    if (ts.isIdentifier(node)) {
+        return true;
+    }
+    if (ts.isPropertyAccessExpression(node)) {
+        return isPropertyAccessOrId(ts, node.expression);
+    }
+    return false;
+}
+//# sourceMappingURL=elementEvents.js.map

node_modules/@vue/language-core/lib/codegen/template/elementProps.d.ts

@@ -0,0 +1,9 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateElementProps(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, props: CompilerDOM.ElementNode['props'], enableCodeFeatures: boolean, propsFailedExps?: {
+    node: CompilerDOM.SimpleExpressionNode;
+    prefix: string;
+    suffix: string;
+}[]): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/elementProps.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementProps = generateElementProps;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const minimatch_1 = require("minimatch");
+const muggle_string_1 = require("muggle-string");
+const shared_2 = require("../../utils/shared");
+const common_1 = require("../common");
+const camelized_1 = require("./camelized");
+const elementEvents_1 = require("./elementEvents");
+const interpolation_1 = require("./interpolation");
+const objectProperty_1 = require("./objectProperty");
+const inlayHints_1 = require("../inlayHints");
+function* generateElementProps(options, ctx, node, props, enableCodeFeatures, propsFailedExps) {
+    const isComponent = node.tagType === CompilerDOM.ElementTypes.COMPONENT;
+    for (const prop of props) {
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'on') {
+            if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                && !prop.arg.loc.source.startsWith('[')
+                && !prop.arg.loc.source.endsWith(']')) {
+                if (!isComponent) {
+                    yield `...{ `;
+                    yield* (0, elementEvents_1.generateEventArg)(ctx, prop.arg, true);
+                    yield `: `;
+                    yield* (0, elementEvents_1.generateEventExpression)(options, ctx, prop);
+                    yield `}, `;
+                }
+                else {
+                    yield `...{ '${(0, shared_1.camelize)('on-' + prop.arg.loc.source)}': {} as any }, `;
+                }
+            }
+            else if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                && prop.arg.loc.source.startsWith('[')
+                && prop.arg.loc.source.endsWith(']')) {
+                propsFailedExps?.push({ node: prop.arg, prefix: '(', suffix: ')' });
+                propsFailedExps?.push({ node: prop.exp, prefix: '() => {', suffix: '}' });
+            }
+            else if (!prop.arg
+                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                propsFailedExps?.push({ node: prop.exp, prefix: '(', suffix: ')' });
+            }
+        }
+    }
+    for (const prop of props) {
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && ((prop.name === 'bind' && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION)
+                || prop.name === 'model')
+            && (!prop.exp || prop.exp.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION)) {
+            let propName;
+            if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+                propName = prop.arg.constType === CompilerDOM.ConstantTypes.CAN_STRINGIFY
+                    ? prop.arg.content
+                    : prop.arg.loc.source;
+            }
+            else {
+                propName = getModelValuePropName(node, options.vueCompilerOptions.target, options.vueCompilerOptions);
+            }
+            if (propName === undefined
+                || options.vueCompilerOptions.dataAttributes.some(pattern => (0, minimatch_1.minimatch)(propName, pattern))) {
+                if (prop.exp && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) {
+                    propsFailedExps?.push({ node: prop.exp, prefix: '(', suffix: ')' });
+                }
+                continue;
+            }
+            if (prop.modifiers.some(m => m.content === 'prop' || m.content === 'attr')) {
+                propName = propName.substring(1);
+            }
+            const shouldSpread = propName === 'style' || propName === 'class';
+            const shouldCamelize = isComponent
+                && (!prop.arg || (prop.arg.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic)) // isStatic
+                && (0, shared_2.hyphenateAttr)(propName) === propName
+                && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, minimatch_1.minimatch)(propName, pattern));
+            if (shouldSpread) {
+                yield `...{ `;
+            }
+            const codeInfo = ctx.codeFeatures.withoutHighlightAndCompletion;
+            const codes = (0, common_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,
+                    verification: options.vueCompilerOptions.strictTemplates
+                        ? codeInfo.verification
+                        : {
+                            shouldReport(_source, code) {
+                                if (String(code) === '2353' || String(code) === '2561') {
+                                    return false;
+                                }
+                                return typeof codeInfo.verification === 'object'
+                                    ? codeInfo.verification.shouldReport?.(_source, code) ?? true
+                                    : true;
+                            },
+                        },
+                    navigation: codeInfo.navigation
+                        ? {
+                            resolveRenameNewName: shared_1.camelize,
+                            resolveRenameEditText: shouldCamelize ? shared_2.hyphenateAttr : undefined,
+                        }
+                        : false,
+                }, prop.loc.name_2 ?? (prop.loc.name_2 = {}), shouldCamelize)
+                : (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, ctx.codeFeatures.verification, propName)), `: (`, ...generatePropExp(options, ctx, prop, prop.exp, ctx.codeFeatures.all, prop.arg?.loc.start.offset === prop.exp?.loc.start.offset, enableCodeFeatures), `)`);
+            if (!enableCodeFeatures) {
+                yield (0, muggle_string_1.toString)([...codes]);
+            }
+            else {
+                yield* codes;
+            }
+            if (shouldSpread) {
+                yield ` }`;
+            }
+            yield `, `;
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
+            if (options.vueCompilerOptions.dataAttributes.some(pattern => (0, minimatch_1.minimatch)(prop.name, pattern))
+                // Vue 2 Transition doesn't support "persisted" property but `@vue/compiler-dom always adds it (#3881)
+                || (options.vueCompilerOptions.target < 3
+                    && prop.name === 'persisted'
+                    && node.tag.toLowerCase() === 'transition')) {
+                continue;
+            }
+            const shouldSpread = prop.name === 'style' || prop.name === 'class';
+            const shouldCamelize = isComponent
+                && (0, shared_2.hyphenateAttr)(prop.name) === prop.name
+                && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, minimatch_1.minimatch)(prop.name, pattern));
+            if (shouldSpread) {
+                yield `...{ `;
+            }
+            const codeInfo = shouldCamelize
+                ? {
+                    ...ctx.codeFeatures.withoutHighlightAndCompletion,
+                    navigation: ctx.codeFeatures.withoutHighlightAndCompletion.navigation
+                        ? {
+                            resolveRenameNewName: shared_1.camelize,
+                            resolveRenameEditText: shared_2.hyphenateAttr,
+                        }
+                        : false,
+                }
+                : {
+                    ...ctx.codeFeatures.withoutHighlightAndCompletion,
+                };
+            if (!options.vueCompilerOptions.strictTemplates) {
+                const verification = codeInfo.verification;
+                codeInfo.verification = {
+                    shouldReport(_source, code) {
+                        if (String(code) === '2353' || String(code) === '2561') {
+                            return false;
+                        }
+                        return typeof verification === 'object'
+                            ? verification.shouldReport?.(_source, code) ?? true
+                            : true;
+                    },
+                };
+            }
+            const codes = (0, common_1.conditionWrapWith)(enableCodeFeatures, prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, codeInfo, prop.loc.name_1 ?? (prop.loc.name_1 = {}), shouldCamelize), `: (`, ...(prop.value
+                ? generateAttrValue(prop.value, ctx.codeFeatures.all)
+                : [`true`]), `)`);
+            if (!enableCodeFeatures) {
+                yield (0, muggle_string_1.toString)([...codes]);
+            }
+            else {
+                yield* codes;
+            }
+            if (shouldSpread) {
+                yield ` }`;
+            }
+            yield `, `;
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'bind'
+            && !prop.arg
+            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            const codes = (0, common_1.conditionWrapWith)(enableCodeFeatures, prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, `...`, ...(0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')'));
+            if (!enableCodeFeatures) {
+                yield (0, muggle_string_1.toString)([...codes]);
+            }
+            else {
+                yield* codes;
+            }
+            yield `, `;
+        }
+        else {
+            // comment this line to avoid affecting comments in prop expressions
+            // tsCodeGen.addText("/* " + [prop.type, prop.name, prop.arg?.loc.source, prop.exp?.loc.source, prop.loc.source].join(", ") + " */ ");
+        }
+    }
+}
+function* generatePropExp(options, ctx, prop, exp, features, isShorthand, enableCodeFeatures) {
+    if (isShorthand && features.completion) {
+        features = {
+            ...features,
+            completion: undefined,
+        };
+    }
+    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, exp.loc.source, exp.loc, exp.loc.start.offset, features, '(', ')');
+        }
+        else {
+            const propVariableName = (0, shared_1.camelize)(exp.loc.source);
+            if (common_1.variableNameRegex.test(propVariableName)) {
+                if (!ctx.hasLocalVariable(propVariableName)) {
+                    ctx.accessExternalVariable(propVariableName, exp.loc.start.offset);
+                    yield `__VLS_ctx.`;
+                }
+                yield* (0, camelized_1.generateCamelized)(exp.loc.source, exp.loc.start.offset, features);
+                if (enableCodeFeatures) {
+                    ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(prop.loc, propVariableName));
+                }
+            }
+        }
+    }
+    else {
+        yield `{}`;
+    }
+}
+function* generateAttrValue(attrNode, features) {
+    const char = attrNode.loc.source.startsWith("'") ? "'" : '"';
+    yield char;
+    let start = attrNode.loc.start.offset;
+    let end = attrNode.loc.end.offset;
+    let content = attrNode.loc.source;
+    if ((content.startsWith('"') && content.endsWith('"'))
+        || (content.startsWith("'") && content.endsWith("'"))) {
+        start++;
+        end--;
+        content = content.slice(1, -1);
+    }
+    if (needToUnicode(content)) {
+        yield* (0, common_1.wrapWith)(start, end, features, toUnicode(content));
+    }
+    else {
+        yield [content, 'template', start, features];
+    }
+    yield char;
+}
+function needToUnicode(str) {
+    return str.includes('\\') || str.includes('\n');
+}
+function toUnicode(str) {
+    return str.split('').map(value => {
+        const temp = value.charCodeAt(0).toString(16).padStart(4, '0');
+        if (temp.length > 2) {
+            return '\\u' + temp;
+        }
+        return value;
+    }).join('');
+}
+function getModelValuePropName(node, vueVersion, vueCompilerOptions) {
+    for (const modelName in vueCompilerOptions.experimentalModelPropName) {
+        const tags = vueCompilerOptions.experimentalModelPropName[modelName];
+        for (const tag in tags) {
+            if (node.tag === tag || node.tag === (0, shared_2.hyphenateTag)(tag)) {
+                const v = tags[tag];
+                if (typeof v === 'object') {
+                    const arr = Array.isArray(v) ? v : [v];
+                    for (const attrs of arr) {
+                        let failed = false;
+                        for (const attr in attrs) {
+                            const attrNode = node.props.find(prop => prop.type === CompilerDOM.NodeTypes.ATTRIBUTE && prop.name === attr);
+                            if (!attrNode || attrNode.value?.content !== attrs[attr]) {
+                                failed = true;
+                                break;
+                            }
+                        }
+                        if (!failed) {
+                            // all match
+                            return modelName || undefined;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    for (const modelName in vueCompilerOptions.experimentalModelPropName) {
+        const tags = vueCompilerOptions.experimentalModelPropName[modelName];
+        for (const tag in tags) {
+            if (node.tag === tag || node.tag === (0, shared_2.hyphenateTag)(tag)) {
+                const attrs = tags[tag];
+                if (attrs === true) {
+                    return modelName || undefined;
+                }
+            }
+        }
+    }
+    return vueVersion < 3 ? 'value' : 'modelValue';
+}
+//# sourceMappingURL=elementProps.js.map

node_modules/@vue/language-core/lib/codegen/template/index.d.ts

@@ -0,0 +1,21 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type * as ts from 'typescript';
+import type { Code, Sfc, VueCompilerOptions } from '../../types';
+import { TemplateCodegenContext } from './context';
+export interface TemplateCodegenOptions {
+    ts: typeof ts;
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    template: NonNullable<Sfc['template']>;
+    edited: boolean;
+    scriptSetupBindingNames: Set<string>;
+    scriptSetupImportComponentNames: Set<string>;
+    destructuredPropNames: Set<string>;
+    templateRefNames: Set<string>;
+    hasDefineSlots?: boolean;
+    slotsAssignName?: string;
+    propsAssignName?: string;
+    inheritAttrs: boolean;
+}
+export declare function generateTemplate(options: TemplateCodegenOptions): Generator<Code, TemplateCodegenContext>;
+export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;

node_modules/@vue/language-core/lib/codegen/template/index.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTemplate = generateTemplate;
+exports.forEachElementNode = forEachElementNode;
+const CompilerDOM = require("@vue/compiler-dom");
+const common_1 = require("../common");
+const context_1 = require("./context");
+const element_1 = require("./element");
+const objectProperty_1 = require("./objectProperty");
+const stringLiteralKey_1 = require("./stringLiteralKey");
+const templateChild_1 = require("./templateChild");
+const styleScopedClasses_1 = require("./styleScopedClasses");
+function* generateTemplate(options) {
+    const ctx = (0, context_1.createTemplateCodegenContext)(options);
+    if (options.slotsAssignName) {
+        ctx.addLocalVariable(options.slotsAssignName);
+    }
+    if (options.propsAssignName) {
+        ctx.addLocalVariable(options.propsAssignName);
+    }
+    ctx.addLocalVariable('$el');
+    ctx.addLocalVariable('$refs');
+    yield* generatePreResolveComponents(options);
+    if (options.template.ast) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, options.template.ast, undefined, undefined, undefined);
+    }
+    yield* (0, styleScopedClasses_1.generateStyleScopedClasses)(ctx);
+    if (!options.hasDefineSlots) {
+        yield `var __VLS_slots!:`;
+        yield* generateSlotsType(options, ctx);
+        yield common_1.endOfLine;
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield* generateInheritedAttrs(ctx);
+    yield* generateRefs(ctx);
+    yield* generateRootEl(ctx);
+    return ctx;
+}
+function* generateSlotsType(options, ctx) {
+    for (const { expVar, varName } of ctx.dynamicSlots) {
+        ctx.hasSlot = true;
+        yield `Partial<Record<NonNullable<typeof ${expVar}>, (_: typeof ${varName}) => any>> &${common_1.newLine}`;
+    }
+    yield `{${common_1.newLine}`;
+    for (const slot of ctx.slots) {
+        ctx.hasSlot = true;
+        if (slot.name && slot.loc !== undefined) {
+            yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.loc, ctx.codeFeatures.withoutHighlightAndCompletion, slot.nodeLoc);
+        }
+        else {
+            yield* (0, common_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+        }
+        yield `?(_: typeof ${slot.varName}): any,${common_1.newLine}`;
+    }
+    yield `}`;
+}
+function* generateInheritedAttrs(ctx) {
+    yield 'var __VLS_inheritedAttrs!: {}';
+    for (const varName of ctx.inheritedAttrVars) {
+        yield ` & typeof ${varName}`;
+    }
+    yield common_1.endOfLine;
+}
+function* generateRefs(ctx) {
+    yield `const __VLS_refs = {${common_1.newLine}`;
+    for (const [name, [varName, offset]] of ctx.templateRefs) {
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(name, offset, ctx.codeFeatures.navigationAndCompletion);
+        yield `: ${varName},${common_1.newLine}`;
+    }
+    yield `}${common_1.endOfLine}`;
+    yield `var $refs!: typeof __VLS_refs${common_1.endOfLine}`;
+}
+function* generateRootEl(ctx) {
+    if (ctx.singleRootElType) {
+        yield `var $el!: ${ctx.singleRootElType}${common_1.endOfLine}`;
+    }
+    else {
+        yield `var $el!: any${common_1.endOfLine}`;
+    }
+}
+function* generatePreResolveComponents(options) {
+    yield `let __VLS_resolvedLocalAndGlobalComponents!: Required<{}`;
+    if (options.template.ast) {
+        const components = new Set();
+        for (const node of forEachElementNode(options.template.ast)) {
+            if (node.tagType === CompilerDOM.ElementTypes.COMPONENT
+                && node.tag.toLowerCase() !== 'component'
+                && !node.tag.includes('.') // namespace tag 
+            ) {
+                if (components.has(node.tag)) {
+                    continue;
+                }
+                components.add(node.tag);
+                yield common_1.newLine;
+                yield ` & __VLS_WithComponent<'${(0, element_1.getCanonicalComponentName)(node.tag)}', typeof __VLS_localComponents, `;
+                yield (0, element_1.getPossibleOriginalComponentNames)(node.tag, false)
+                    .map(name => `"${name}"`)
+                    .join(', ');
+                yield `>`;
+            }
+        }
+    }
+    yield `>${common_1.endOfLine}`;
+}
+function* forEachElementNode(node) {
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        const patchForNode = (0, templateChild_1.getVForNode)(node);
+        if (patchForNode) {
+            yield* forEachElementNode(patchForNode);
+        }
+        else {
+            yield node;
+            for (const child of node.children) {
+                yield* forEachElementNode(child);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        // v-if / v-else-if / v-else
+        for (let i = 0; i < node.branches.length; i++) {
+            const branch = node.branches[i];
+            for (const childNode of branch.children) {
+                yield* forEachElementNode(childNode);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        // v-for
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+}
+//# sourceMappingURL=index.js.map

node_modules/@vue/language-core/lib/codegen/template/interpolation.d.ts

@@ -0,0 +1,6 @@
+import type * as ts from 'typescript';
+import type { Code, VueCodeInformation } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateInterpolation(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, _code: string, astHolder: any, start: number | undefined, data: VueCodeInformation | ((offset: number) => VueCodeInformation) | undefined, prefix: string, suffix: string): Generator<Code>;
+export declare function forEachInterpolationSegment(ts: typeof import('typescript'), destructuredPropNames: Set<string> | undefined, templateRefNames: Set<string> | undefined, ctx: TemplateCodegenContext, code: string, offset: number | undefined, ast: ts.SourceFile): Generator<[fragment: string, offset: number | undefined, type?: 'errorMappingOnly' | 'startText' | 'endText']>;

node_modules/@vue/language-core/lib/codegen/template/interpolation.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInterpolation = generateInterpolation;
+exports.forEachInterpolationSegment = forEachInterpolationSegment;
+const shared_1 = require("@vue/shared");
+const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
+const common_1 = require("../common");
+function* generateInterpolation(options, ctx, _code, astHolder, start, data, prefix, suffix) {
+    const code = prefix + _code + suffix;
+    const ast = (0, common_1.createTsAst)(options.ts, astHolder, code);
+    for (let [section, offset, type] of forEachInterpolationSegment(options.ts, options.destructuredPropNames, options.templateRefNames, ctx, code, start !== undefined ? start - prefix.length : undefined, ast)) {
+        if (offset === undefined) {
+            yield section;
+        }
+        else {
+            offset -= prefix.length;
+            let addSuffix = '';
+            const overLength = offset + section.length - _code.length;
+            if (overLength > 0) {
+                addSuffix = section.substring(section.length - overLength);
+                section = section.substring(0, section.length - overLength);
+            }
+            if (offset < 0) {
+                yield section.substring(0, -offset);
+                section = section.substring(-offset);
+                offset = 0;
+            }
+            const shouldSkip = section.length === 0 && (type === 'startText' || type === 'endText');
+            if (!shouldSkip) {
+                if (start !== undefined
+                    && data) {
+                    yield [
+                        section,
+                        'template',
+                        start + offset,
+                        type === 'errorMappingOnly'
+                            ? ctx.codeFeatures.verification
+                            : typeof data === 'function' ? data(start + offset) : data,
+                    ];
+                }
+                else {
+                    yield section;
+                }
+            }
+            yield addSuffix;
+        }
+    }
+}
+function* forEachInterpolationSegment(ts, destructuredPropNames, templateRefNames, ctx, code, offset, ast) {
+    let ctxVars = [];
+    const varCb = (id, isShorthand) => {
+        const text = (0, scriptSetupRanges_1.getNodeText)(ts, id, ast);
+        if (ctx.hasLocalVariable(text) ||
+            // https://github.com/vuejs/core/blob/245230e135152900189f13a4281302de45fdcfaa/packages/compiler-core/src/transforms/transformExpression.ts#L342-L352
+            (0, shared_1.isGloballyWhitelisted)(text) ||
+            text === 'require' ||
+            text.startsWith('__VLS_')) {
+            // localVarOffsets.push(localVar.getStart(ast));
+        }
+        else {
+            ctxVars.push({
+                text,
+                isShorthand: isShorthand,
+                offset: (0, scriptSetupRanges_1.getStartEnd)(ts, id, ast).start,
+            });
+            if (destructuredPropNames?.has(text)) {
+                return;
+            }
+            if (offset !== undefined) {
+                ctx.accessExternalVariable(text, offset + (0, scriptSetupRanges_1.getStartEnd)(ts, id, ast).start);
+            }
+            else {
+                ctx.accessExternalVariable(text);
+            }
+        }
+    };
+    ts.forEachChild(ast, node => walkIdentifiers(ts, node, ast, varCb, ctx));
+    ctxVars = ctxVars.sort((a, b) => a.offset - b.offset);
+    if (ctxVars.length) {
+        if (ctxVars[0].isShorthand) {
+            yield [code.substring(0, ctxVars[0].offset + ctxVars[0].text.length), 0];
+            yield [': ', undefined];
+        }
+        else if (ctxVars[0].offset > 0) {
+            yield [code.substring(0, ctxVars[0].offset), 0, 'startText'];
+        }
+        for (let i = 0; i < ctxVars.length - 1; i++) {
+            const curVar = ctxVars[i];
+            const nextVar = ctxVars[i + 1];
+            yield* generateVar(code, destructuredPropNames, templateRefNames, curVar, nextVar);
+            if (nextVar.isShorthand) {
+                yield [code.substring(curVar.offset + curVar.text.length, nextVar.offset + nextVar.text.length), curVar.offset + curVar.text.length];
+                yield [': ', undefined];
+            }
+            else {
+                yield [code.substring(curVar.offset + curVar.text.length, nextVar.offset), curVar.offset + curVar.text.length];
+            }
+        }
+        const lastVar = ctxVars.at(-1);
+        yield* generateVar(code, destructuredPropNames, templateRefNames, lastVar);
+        if (lastVar.offset + lastVar.text.length < code.length) {
+            yield [code.substring(lastVar.offset + lastVar.text.length), lastVar.offset + lastVar.text.length, 'endText'];
+        }
+    }
+    else {
+        yield [code, 0];
+    }
+}
+function* generateVar(code, destructuredPropNames, templateRefNames, curVar, nextVar = curVar) {
+    // fix https://github.com/vuejs/language-tools/issues/1205
+    // fix https://github.com/vuejs/language-tools/issues/1264
+    yield ['', nextVar.offset, 'errorMappingOnly'];
+    const isDestructuredProp = destructuredPropNames?.has(curVar.text) ?? false;
+    const isTemplateRef = templateRefNames?.has(curVar.text) ?? false;
+    if (isTemplateRef) {
+        yield [`__VLS_unref(`, undefined];
+        yield [code.substring(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
+        yield [`)`, undefined];
+    }
+    else {
+        if (!isDestructuredProp) {
+            yield [`__VLS_ctx.`, undefined];
+        }
+        yield [code.substring(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
+    }
+}
+function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true) {
+    if (ts.isIdentifier(node)) {
+        cb(node, false);
+    }
+    else if (ts.isShorthandPropertyAssignment(node)) {
+        cb(node.name, true);
+    }
+    else if (ts.isPropertyAccessExpression(node)) {
+        walkIdentifiers(ts, node.expression, ast, cb, ctx, blockVars, false);
+    }
+    else if (ts.isVariableDeclaration(node)) {
+        (0, common_1.collectVars)(ts, node.name, ast, blockVars);
+        for (const varName of blockVars) {
+            ctx.addLocalVariable(varName);
+        }
+        if (node.initializer) {
+            walkIdentifiers(ts, node.initializer, ast, cb, ctx, blockVars, false);
+        }
+    }
+    else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        processFunction(ts, node, ast, cb, ctx);
+    }
+    else if (ts.isObjectLiteralExpression(node)) {
+        for (const prop of node.properties) {
+            if (ts.isPropertyAssignment(prop)) {
+                // fix https://github.com/vuejs/language-tools/issues/1176
+                if (ts.isComputedPropertyName(prop.name)) {
+                    walkIdentifiers(ts, prop.name.expression, ast, cb, ctx, blockVars, false);
+                }
+                walkIdentifiers(ts, prop.initializer, ast, cb, ctx, blockVars, false);
+            }
+            // fix https://github.com/vuejs/language-tools/issues/1156
+            else if (ts.isShorthandPropertyAssignment(prop)) {
+                walkIdentifiers(ts, prop, ast, cb, ctx, blockVars, false);
+            }
+            // fix https://github.com/vuejs/language-tools/issues/1148#issuecomment-1094378126
+            else if (ts.isSpreadAssignment(prop)) {
+                // TODO: cannot report "Spread types may only be created from object types.ts(2698)"
+                walkIdentifiers(ts, prop.expression, ast, cb, ctx, blockVars, false);
+            }
+            // fix https://github.com/vuejs/language-tools/issues/4604
+            else if (ts.isFunctionLike(prop) && prop.body) {
+                processFunction(ts, prop, ast, cb, ctx);
+            }
+        }
+    }
+    else if (ts.isTypeReferenceNode(node)) {
+        // fix https://github.com/vuejs/language-tools/issues/1422
+        ts.forEachChild(node, node => walkIdentifiersInTypeReference(ts, node, cb));
+    }
+    else {
+        const _blockVars = blockVars;
+        if (ts.isBlock(node)) {
+            blockVars = [];
+        }
+        ts.forEachChild(node, node => walkIdentifiers(ts, node, ast, cb, ctx, blockVars, false));
+        if (ts.isBlock(node)) {
+            for (const varName of blockVars) {
+                ctx.removeLocalVariable(varName);
+            }
+        }
+        blockVars = _blockVars;
+    }
+    if (isRoot) {
+        for (const varName of blockVars) {
+            ctx.removeLocalVariable(varName);
+        }
+    }
+}
+function processFunction(ts, node, ast, cb, ctx) {
+    const functionArgs = [];
+    for (const param of node.parameters) {
+        (0, common_1.collectVars)(ts, param.name, ast, functionArgs);
+        if (param.type) {
+            walkIdentifiers(ts, param.type, ast, cb, ctx);
+        }
+    }
+    for (const varName of functionArgs) {
+        ctx.addLocalVariable(varName);
+    }
+    if (node.body) {
+        walkIdentifiers(ts, node.body, ast, cb, ctx);
+    }
+    for (const varName of functionArgs) {
+        ctx.removeLocalVariable(varName);
+    }
+}
+function walkIdentifiersInTypeReference(ts, node, cb) {
+    if (ts.isTypeQueryNode(node) && ts.isIdentifier(node.exprName)) {
+        cb(node.exprName, false);
+    }
+    else {
+        ts.forEachChild(node, node => walkIdentifiersInTypeReference(ts, node, cb));
+    }
+}
+//# sourceMappingURL=interpolation.js.map

node_modules/@vue/language-core/lib/codegen/template/objectProperty.d.ts

@@ -0,0 +1,4 @@
+import type { Code, VueCodeInformation } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateObjectProperty(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset: number, features: VueCodeInformation, astHolder?: any, shouldCamelize?: boolean, shouldBeConstant?: boolean): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/objectProperty.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateObjectProperty = generateObjectProperty;
+const shared_1 = require("@vue/shared");
+const common_1 = require("../common");
+const camelized_1 = require("./camelized");
+const interpolation_1 = require("./interpolation");
+const stringLiteralKey_1 = require("./stringLiteralKey");
+function* generateObjectProperty(options, ctx, code, offset, features, astHolder, shouldCamelize = false, shouldBeConstant = false) {
+    if (code.startsWith('[') && code.endsWith(']') && astHolder) {
+        if (shouldBeConstant) {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, code.slice(1, -1), astHolder, offset + 1, features, `[__VLS_tryAsConstant(`, `)]`);
+        }
+        else {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, code, astHolder, offset, features, '', '');
+        }
+    }
+    else if (shouldCamelize) {
+        if (common_1.variableNameRegex.test((0, shared_1.camelize)(code))) {
+            yield* (0, camelized_1.generateCamelized)(code, offset, features);
+        }
+        else {
+            yield* (0, common_1.wrapWith)(offset, offset + code.length, features, `"`, ...(0, camelized_1.generateCamelized)(code, offset, common_1.combineLastMapping), `"`);
+        }
+    }
+    else {
+        if (common_1.variableNameRegex.test(code)) {
+            yield [code, 'template', offset, features];
+        }
+        else {
+            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(code, offset, features);
+        }
+    }
+}
+//# sourceMappingURL=objectProperty.js.map

node_modules/@vue/language-core/lib/codegen/template/propertyAccess.d.ts

@@ -0,0 +1,4 @@
+import type { Code, VueCodeInformation } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generatePropertyAccess(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset?: number, features?: VueCodeInformation, astHolder?: any): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/propertyAccess.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePropertyAccess = generatePropertyAccess;
+const common_1 = require("../common");
+const interpolation_1 = require("./interpolation");
+const stringLiteralKey_1 = require("./stringLiteralKey");
+function* generatePropertyAccess(options, ctx, code, offset, features, astHolder) {
+    if (!options.compilerOptions.noPropertyAccessFromIndexSignature && common_1.variableNameRegex.test(code)) {
+        yield `.`;
+        yield offset !== undefined && features
+            ? [code, 'template', offset, features]
+            : code;
+    }
+    else if (code.startsWith('[') && code.endsWith(']')) {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, code, astHolder, offset, features, '', '');
+    }
+    else {
+        yield `[`;
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(code, offset, features);
+        yield `]`;
+    }
+}
+//# sourceMappingURL=propertyAccess.js.map

node_modules/@vue/language-core/lib/codegen/template/slotOutlet.d.ts

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

node_modules/@vue/language-core/lib/codegen/template/slotOutlet.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSlotOutlet = generateSlotOutlet;
+const CompilerDOM = require("@vue/compiler-dom");
+const common_1 = require("../common");
+const elementChildren_1 = require("./elementChildren");
+const elementProps_1 = require("./elementProps");
+const interpolation_1 = require("./interpolation");
+const inlayHints_1 = require("../inlayHints");
+function* generateSlotOutlet(options, ctx, node, currentComponent, componentCtxVar) {
+    const startTagOffset = node.loc.start.offset + options.template.content.substring(node.loc.start.offset).indexOf(node.tag);
+    const varSlot = ctx.getInternalVariable();
+    const nameProp = node.props.find(prop => {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
+            return prop.name === 'name';
+        }
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'bind'
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            return prop.arg.content === 'name';
+        }
+    });
+    if (options.hasDefineSlots) {
+        yield `__VLS_normalizeSlot(`;
+        yield* (0, common_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, common_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, ctx.codeFeatures.verification, nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE && nameProp.value
+            ? `'${nameProp.value.content}'`
+            : nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                ? nameProp.exp.content
+                : `('default' as const)`), `]`);
+        yield `)?.(`;
+        yield* (0, common_1.wrapWith)(startTagOffset, startTagOffset + node.tag.length, ctx.codeFeatures.verification, `{${common_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true), `}`);
+        yield `)${common_1.endOfLine}`;
+    }
+    else {
+        yield `var ${varSlot} = {${common_1.newLine}`;
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true);
+        yield `}${common_1.endOfLine}`;
+        if (nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && nameProp.value) {
+            ctx.slots.push({
+                name: nameProp.value.content,
+                loc: nameProp.loc.start.offset + nameProp.loc.source.indexOf(nameProp.value.content, nameProp.name.length),
+                tagRange: [startTagOffset, startTagOffset + node.tag.length],
+                varName: varSlot,
+                nodeLoc: node.loc,
+            });
+        }
+        else if (nameProp?.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            const isShortHand = nameProp.arg?.loc.start.offset === nameProp.exp.loc.start.offset;
+            if (isShortHand) {
+                ctx.inlayHints.push((0, inlayHints_1.createVBindShorthandInlayHintInfo)(nameProp.exp.loc, 'name'));
+            }
+            const slotExpVar = ctx.getInternalVariable();
+            yield `var ${slotExpVar} = `;
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, nameProp.exp.content, nameProp.exp, nameProp.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+            yield ` as const${common_1.endOfLine}`;
+            ctx.dynamicSlots.push({
+                expVar: slotExpVar,
+                varName: varSlot,
+            });
+        }
+        else {
+            ctx.slots.push({
+                name: 'default',
+                tagRange: [startTagOffset, startTagOffset + node.tag.length],
+                varName: varSlot,
+                nodeLoc: node.loc,
+            });
+        }
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentComponent, componentCtxVar);
+}
+//# sourceMappingURL=slotOutlet.js.map

node_modules/@vue/language-core/lib/codegen/template/stringLiteralKey.d.ts

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from '../../types';
+export declare function generateStringLiteralKey(code: string, offset?: number, info?: VueCodeInformation): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/stringLiteralKey.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStringLiteralKey = generateStringLiteralKey;
+const common_1 = require("../common");
+function* generateStringLiteralKey(code, offset, info) {
+    if (offset === undefined || !info) {
+        yield `"${code}"`;
+    }
+    else {
+        yield* (0, common_1.wrapWith)(offset, offset + code.length, info, `"`, [code, 'template', offset, common_1.combineLastMapping], `"`);
+    }
+}
+//# sourceMappingURL=stringLiteralKey.js.map

node_modules/@vue/language-core/lib/codegen/template/styleScopedClasses.d.ts

@@ -0,0 +1,3 @@
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+export declare function generateStyleScopedClasses(ctx: TemplateCodegenContext, withDot?: boolean): Generator<Code>;

node_modules/@vue/language-core/lib/codegen/template/styleScopedClasses.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStyleScopedClasses = generateStyleScopedClasses;
+const common_1 = require("../common");
+function* generateStyleScopedClasses(ctx, withDot = false) {
+    for (const offset of ctx.emptyClassOffsets) {
+        yield `__VLS_styleScopedClasses['`;
+        yield [
+            '',
+            'template',
+            offset,
+            ctx.codeFeatures.additionalCompletion,
+        ];
+        yield `']${common_1.endOfLine}`;
+    }
+    for (const { source, className, offset } of ctx.scopedClasses) {
+        yield `__VLS_styleScopedClasses[`;
+        yield [
+            '',
+            source,
+            offset - (withDot ? 1 : 0),
+            ctx.codeFeatures.navigation,
+        ];
+        yield `'`;
+        // fix https://github.com/vuejs/language-tools/issues/4537
+        yield* escapeString(source, className, offset, ['\\', '\'']);
+        yield `'`;
+        yield [
+            '',
+            source,
+            offset + className.length,
+            ctx.codeFeatures.navigationWithoutRename,
+        ];
+        yield `]${common_1.endOfLine}`;
+    }
+    yield common_1.newLine;
+    function* escapeString(source, className, offset, escapeTargets) {
+        let count = 0;
+        const currentEscapeTargets = [...escapeTargets];
+        const firstEscapeTarget = currentEscapeTargets.shift();
+        const splitted = className.split(firstEscapeTarget);
+        for (let i = 0; i < splitted.length; i++) {
+            const part = splitted[i];
+            const partLength = part.length;
+            if (escapeTargets.length > 0) {
+                yield* escapeString(source, part, offset + count, [...currentEscapeTargets]);
+            }
+            else {
+                yield [
+                    part,
+                    source,
+                    offset + count,
+                    ctx.codeFeatures.navigationAndAdditionalCompletion,
+                ];
+            }
+            if (i !== splitted.length - 1) {
+                yield '\\';
+                yield [
+                    firstEscapeTarget,
+                    source,
+                    offset + count + partLength,
+                    ctx.codeFeatures.navigationAndAdditionalCompletion,
+                ];
+                count += partLength + 1;
+            }
+            else {
+                count += partLength;
+            }
+        }
+    }
+}
+//# sourceMappingURL=styleScopedClasses.js.map

node_modules/@vue/language-core/lib/codegen/template/templateChild.d.ts

@@ -0,0 +1,7 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, currentComponent: CompilerDOM.ElementNode | undefined, prevNode: CompilerDOM.TemplateChildNode | undefined, componentCtxVar: string | undefined, isVForChild?: boolean): Generator<Code>;
+export declare function getVForNode(node: CompilerDOM.ElementNode): CompilerDOM.ForNode | undefined;
+export declare function parseInterpolationNode(node: CompilerDOM.InterpolationNode, template: string): readonly [string, number];

node_modules/@vue/language-core/lib/codegen/template/templateChild.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTemplateChild = generateTemplateChild;
+exports.getVForNode = getVForNode;
+exports.parseInterpolationNode = parseInterpolationNode;
+const CompilerDOM = require("@vue/compiler-dom");
+const common_1 = require("../common");
+const element_1 = require("./element");
+const interpolation_1 = require("./interpolation");
+const slotOutlet_1 = require("./slotOutlet");
+const vFor_1 = require("./vFor");
+const vIf_1 = require("./vIf");
+// @ts-ignore
+const transformContext = {
+    onError: () => { },
+    helperString: str => str.toString(),
+    replaceNode: () => { },
+    cacheHandlers: false,
+    prefixIdentifiers: false,
+    scopes: {
+        vFor: 0,
+        vOnce: 0,
+        vPre: 0,
+        vSlot: 0,
+    },
+    expressionPlugins: ['typescript'],
+};
+function* generateTemplateChild(options, ctx, node, currentComponent, prevNode, componentCtxVar, isVForChild = false) {
+    if (prevNode?.type === CompilerDOM.NodeTypes.COMMENT) {
+        const commentText = prevNode.content.trim().split(' ')[0];
+        if (commentText.match(/^@vue-skip\b[\s\S]*/)) {
+            yield `// @vue-skip${common_1.newLine}`;
+            return;
+        }
+        else if (commentText.match(/^@vue-ignore\b[\s\S]*/)) {
+            yield* ctx.ignoreError();
+        }
+        else if (commentText.match(/^@vue-expect-error\b[\s\S]*/)) {
+            yield* ctx.expectError(prevNode);
+        }
+    }
+    const shouldInheritRootNodeAttrs = options.inheritAttrs;
+    const cur = node;
+    if (cur.codegenNode?.type === CompilerDOM.NodeTypes.JS_CACHE_EXPRESSION) {
+        cur.codegenNode = cur.codegenNode.value;
+    }
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        let prev;
+        if (shouldInheritRootNodeAttrs && node.children.length === 1 && node.children[0].type === CompilerDOM.NodeTypes.ELEMENT) {
+            ctx.singleRootNode = node.children[0];
+        }
+        for (const childNode of node.children) {
+            yield* generateTemplateChild(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+            prev = childNode;
+        }
+        yield* ctx.resetDirectiveComments('end of root');
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        const vForNode = getVForNode(node);
+        const vIfNode = getVIfNode(node);
+        if (vForNode) {
+            yield* (0, vFor_1.generateVFor)(options, ctx, vForNode, currentComponent, componentCtxVar);
+        }
+        else if (vIfNode) {
+            yield* (0, vIf_1.generateVIf)(options, ctx, vIfNode, currentComponent, componentCtxVar);
+        }
+        else {
+            if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
+                yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node, currentComponent, componentCtxVar);
+            }
+            else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
+                || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
+                yield* (0, element_1.generateElement)(options, ctx, node, currentComponent, componentCtxVar, isVForChild);
+            }
+            else {
+                yield* (0, element_1.generateComponent)(options, ctx, node, currentComponent);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
+        // {{ var }}
+        yield* generateTemplateChild(options, ctx, node.content, currentComponent, undefined, componentCtxVar);
+    }
+    else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
+        // {{ ... }} {{ ... }}
+        for (const childNode of node.children) {
+            if (typeof childNode === 'object') {
+                yield* generateTemplateChild(options, ctx, childNode, currentComponent, undefined, componentCtxVar);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
+        // {{ ... }}
+        const [content, start] = parseInterpolationNode(node, options.template.content);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, content, node.content.loc, start, ctx.codeFeatures.all, `(`, `)${common_1.endOfLine}`);
+        yield* ctx.resetDirectiveComments('end of INTERPOLATION');
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        // v-if / v-else-if / v-else
+        yield* (0, vIf_1.generateVIf)(options, ctx, node, currentComponent, componentCtxVar);
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        // v-for
+        yield* (0, vFor_1.generateVFor)(options, ctx, node, currentComponent, componentCtxVar);
+    }
+    else if (node.type === CompilerDOM.NodeTypes.TEXT) {
+        // not needed progress
+    }
+}
+// TODO: track https://github.com/vuejs/vue-next/issues/3498
+function getVForNode(node) {
+    const forDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && prop.name === 'for');
+    if (forDirective) {
+        let forNode;
+        CompilerDOM.processFor(node, forDirective, transformContext, _forNode => {
+            forNode = { ..._forNode };
+            return undefined;
+        });
+        if (forNode) {
+            forNode.children = [{
+                    ...node,
+                    props: node.props.filter(prop => prop !== forDirective),
+                }];
+            return forNode;
+        }
+    }
+}
+function getVIfNode(node) {
+    const forDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && prop.name === 'if');
+    if (forDirective) {
+        let ifNode;
+        CompilerDOM.processIf(node, forDirective, transformContext, _ifNode => {
+            ifNode = { ..._ifNode };
+            return undefined;
+        });
+        if (ifNode) {
+            for (const branch of ifNode.branches) {
+                branch.children = [{
+                        ...node,
+                        props: node.props.filter(prop => prop !== forDirective),
+                    }];
+            }
+            return ifNode;
+        }
+    }
+}
+function parseInterpolationNode(node, template) {
+    let content = node.content.loc.source;
+    let start = node.content.loc.start.offset;
+    let leftCharacter;
+    let rightCharacter;
+    // fix https://github.com/vuejs/language-tools/issues/1787
+    while ((leftCharacter = template.substring(start - 1, start)).trim() === '' && leftCharacter.length) {
+        start--;
+        content = leftCharacter + content;
+    }
+    while ((rightCharacter = template.substring(start + content.length, start + content.length + 1)).trim() === '' && rightCharacter.length) {
+        content = content + rightCharacter;
+    }
+    return [
+        content,
+        start,
+    ];
+}
+//# sourceMappingURL=templateChild.js.map

node_modules/@vue/language-core/lib/codegen/template/vFor.d.ts

@@ -0,0 +1,12 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateVFor(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ForNode, currentComponent: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function parseVForNode(node: CompilerDOM.ForNode): {
+    leftExpressionRange: {
+        start: number;
+        end: number;
+    } | undefined;
+    leftExpressionText: string | undefined;
+};

node_modules/@vue/language-core/lib/codegen/template/vFor.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVFor = generateVFor;
+exports.parseVForNode = parseVForNode;
+const CompilerDOM = require("@vue/compiler-dom");
+const common_1 = require("../common");
+const interpolation_1 = require("./interpolation");
+const templateChild_1 = require("./templateChild");
+function* generateVFor(options, ctx, node, currentComponent, componentCtxVar) {
+    const { source } = node.parseResult;
+    const { leftExpressionRange, leftExpressionText } = parseVForNode(node);
+    const forBlockVars = [];
+    yield `for (const [`;
+    if (leftExpressionRange && leftExpressionText) {
+        const collectAst = (0, common_1.createTsAst)(options.ts, node.parseResult, `const [${leftExpressionText}]`);
+        (0, common_1.collectVars)(options.ts, collectAst, collectAst, forBlockVars);
+        yield [
+            leftExpressionText,
+            'template',
+            leftExpressionRange.start,
+            ctx.codeFeatures.all,
+        ];
+    }
+    yield `] of `;
+    if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        yield `__VLS_getVForSourceType(`;
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, source.content, source.loc, source.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+        yield `!)`; // #3102
+    }
+    else {
+        yield `{} as any`;
+    }
+    yield `) {${common_1.newLine}`;
+    for (const varName of forBlockVars) {
+        ctx.addLocalVariable(varName);
+    }
+    let isFragment = true;
+    for (const argument of node.codegenNode?.children.arguments ?? []) {
+        if (argument.type === CompilerDOM.NodeTypes.JS_FUNCTION_EXPRESSION
+            && argument.returns?.type === CompilerDOM.NodeTypes.VNODE_CALL
+            && argument.returns?.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION) {
+            if (argument.returns.tag !== CompilerDOM.FRAGMENT) {
+                isFragment = false;
+                continue;
+            }
+            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, prop.value.content, prop.value.loc, prop.value.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+                    yield common_1.endOfLine;
+                }
+            }
+        }
+    }
+    if (isFragment) {
+        yield* ctx.resetDirectiveComments('end of v-for start');
+    }
+    let prev;
+    for (const childNode of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar, true);
+        prev = childNode;
+    }
+    for (const varName of forBlockVars) {
+        ctx.removeLocalVariable(varName);
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield `}${common_1.newLine}`;
+}
+function parseVForNode(node) {
+    const { value, key, index } = node.parseResult;
+    const leftExpressionRange = (value || key || index)
+        ? {
+            start: (value ?? key ?? index).loc.start.offset,
+            end: (index ?? key ?? value).loc.end.offset,
+        }
+        : undefined;
+    const leftExpressionText = leftExpressionRange
+        ? node.loc.source.substring(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset)
+        : undefined;
+    return {
+        leftExpressionRange,
+        leftExpressionText,
+    };
+}
+//# sourceMappingURL=vFor.js.map

node_modules/@vue/language-core/lib/codegen/template/vIf.d.ts

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

node_modules/@vue/language-core/lib/codegen/template/vIf.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVIf = generateVIf;
+const CompilerDOM = require("@vue/compiler-dom");
+const muggle_string_1 = require("muggle-string");
+const common_1 = require("../common");
+const interpolation_1 = require("./interpolation");
+const templateChild_1 = require("./templateChild");
+function* generateVIf(options, ctx, node, currentComponent, componentCtxVar) {
+    let originalBlockConditionsLength = ctx.blockConditions.length;
+    for (let i = 0; i < node.branches.length; i++) {
+        const branch = node.branches[i];
+        if (i === 0) {
+            yield `if `;
+        }
+        else if (branch.condition) {
+            yield `else if `;
+        }
+        else {
+            yield `else `;
+        }
+        let addedBlockCondition = false;
+        if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            const codes = [
+                ...(0, interpolation_1.generateInterpolation)(options, ctx, branch.condition.content, branch.condition.loc, branch.condition.loc.start.offset, ctx.codeFeatures.all, '(', ')'),
+            ];
+            for (const code of codes) {
+                yield code;
+            }
+            ctx.blockConditions.push((0, muggle_string_1.toString)(codes));
+            addedBlockCondition = true;
+            yield ` `;
+        }
+        yield `{${common_1.newLine}`;
+        if (isFragment(node)) {
+            yield* ctx.resetDirectiveComments('end of v-if start');
+        }
+        let prev;
+        for (const childNode of branch.children) {
+            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentComponent, prev, componentCtxVar);
+            prev = childNode;
+        }
+        yield* ctx.generateAutoImportCompletion();
+        yield `}${common_1.newLine}`;
+        if (addedBlockCondition) {
+            ctx.blockConditions[ctx.blockConditions.length - 1] = `!(${ctx.blockConditions[ctx.blockConditions.length - 1]})`;
+        }
+    }
+    ctx.blockConditions.length = originalBlockConditionsLength;
+}
+function isFragment(node) {
+    return node.codegenNode
+        && 'consequent' in node.codegenNode
+        && 'tag' in node.codegenNode.consequent
+        && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
+}
+//# sourceMappingURL=vIf.js.map