init

node_modules/@vue/language-core/out/generators/script.d.ts

@@ -0,0 +1,15 @@
+import { FileRangeCapabilities, MirrorBehaviorCapabilities } from '@volar/language-core';
+import * as SourceMaps from '@volar/source-map';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type * as templateGen from '../generators/template';
+import type { ScriptRanges } from '../parsers/scriptRanges';
+import type { ScriptSetupRanges } from '../parsers/scriptSetupRanges';
+import type { VueCompilerOptions } from '../types';
+import { Sfc } from '../types';
+export declare function generate(ts: typeof import('typescript/lib/tsserverlibrary'), fileName: string, script: Sfc['script'], scriptSetup: Sfc['scriptSetup'], styles: Sfc['styles'], // TODO: computed it
+lang: string, scriptRanges: ScriptRanges | undefined, scriptSetupRanges: ScriptSetupRanges | undefined, htmlGen: ReturnType<typeof templateGen['generate']> | undefined, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack: boolean): {
+    codes: SourceMaps.Segment<FileRangeCapabilities>[];
+    codeStacks: SourceMaps.StackNode[];
+    mirrorBehaviorMappings: SourceMaps.Mapping<[MirrorBehaviorCapabilities, MirrorBehaviorCapabilities]>[];
+};
+//# sourceMappingURL=script.d.ts.map

node_modules/@vue/language-core/out/generators/script.js

@@ -0,0 +1,870 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = void 0;
+const language_core_1 = require("@volar/language-core");
+const source_map_1 = require("@volar/source-map");
+const muggle = require("muggle-string");
+const path = require("path-browserify");
+const shared_1 = require("../utils/shared");
+const transform_1 = require("../utils/transform");
+function generate(ts, fileName, script, scriptSetup, styles, // TODO: computed it
+lang, scriptRanges, scriptSetupRanges, htmlGen, compilerOptions, vueCompilerOptions, codegenStack) {
+    const [codes, codeStacks] = codegenStack ? muggle.track([]) : [[], []];
+    const mirrorBehaviorMappings = [];
+    //#region monkey fix: https://github.com/vuejs/language-tools/pull/2113
+    if (!script && !scriptSetup) {
+        scriptSetup = {
+            content: '',
+            lang: 'ts',
+            name: '',
+            start: 0,
+            end: 0,
+            startTagEnd: 0,
+            endTagStart: 0,
+            generic: undefined,
+            genericOffset: 0,
+            attrs: {},
+            ast: ts.createSourceFile('', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS),
+        };
+        scriptSetupRanges = {
+            bindings: [],
+            props: {},
+            emits: {},
+            expose: {},
+            slots: {},
+            defineProp: [],
+            importSectionEndOffset: 0,
+            leadingCommentEndOffset: 0,
+        };
+    }
+    //#endregion
+    const bindingNames = new Set([
+        ...scriptRanges?.bindings.map(range => script.content.substring(range.start, range.end)) ?? [],
+        ...scriptSetupRanges?.bindings.map(range => scriptSetup.content.substring(range.start, range.end)) ?? [],
+    ]);
+    const bypassDefineComponent = lang === 'js' || lang === 'jsx';
+    const usedHelperTypes = {
+        DefinePropsToOptions: false,
+        MergePropDefaults: false,
+        WithTemplateSlots: false,
+        PropsChildren: false,
+    };
+    codes.push(`/* __placeholder__ */\n`);
+    let generatedTemplate = false;
+    generateSrc();
+    generateScriptSetupImports();
+    generateScriptContentBeforeExportDefault();
+    generateScriptSetupAndTemplate();
+    generateHelperTypes();
+    generateScriptContentAfterExportDefault();
+    if (!generatedTemplate) {
+        generateTemplate(false);
+    }
+    if (scriptSetup) {
+        // for code action edits
+        codes.push([
+            '',
+            'scriptSetup',
+            scriptSetup.content.length,
+            {},
+        ]);
+    }
+    return {
+        codes,
+        codeStacks,
+        mirrorBehaviorMappings,
+    };
+    function generateHelperTypes() {
+        if (usedHelperTypes.DefinePropsToOptions) {
+            if (compilerOptions.exactOptionalPropertyTypes) {
+                codes.push(`type __VLS_TypePropsToRuntimeProps<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 } };\n`);
+            }
+            else {
+                codes.push(`type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;\n`);
+                codes.push(`type __VLS_TypePropsToRuntimeProps<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 } };\n`);
+            }
+        }
+        if (usedHelperTypes.MergePropDefaults) {
+            codes.push(`type __VLS_WithDefaults<P, D> = {
+					// use 'keyof Pick<P, keyof P>' instead of 'keyof P' to keep props jsdoc
+					[K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+						default: D[K]
+					}> : P[K]
+				};\n`);
+            codes.push(`type __VLS_Prettify<T> = { [K in keyof T]: T[K]; } & {};\n`);
+        }
+        if (usedHelperTypes.WithTemplateSlots) {
+            codes.push(`type __VLS_WithTemplateSlots<T, S> = T & { new(): {\n`, `${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: S;\n`);
+            if (vueCompilerOptions.jsxSlots) {
+                usedHelperTypes.PropsChildren = true;
+                codes.push(`$props: __VLS_PropsChildren<S>;\n`);
+            }
+            codes.push(`} };\n`);
+        }
+        if (usedHelperTypes.PropsChildren) {
+            codes.push(`type __VLS_PropsChildren<S> = { [K in keyof (boolean extends (JSX.ElementChildrenAttribute extends never ? true : false) ? never : JSX.ElementChildrenAttribute)]?: S; };\n`);
+        }
+    }
+    function generateSrc() {
+        if (!script?.src)
+            return;
+        let src = 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';
+        codes.push(`export * from `);
+        codes.push([
+            `'${src}'`,
+            'script',
+            [script.srcOffset - 1, script.srcOffset + script.src.length + 1],
+            {
+                ...language_core_1.FileRangeCapabilities.full,
+                rename: src === script.src ? true : {
+                    normalize: undefined,
+                    apply(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;
+                    },
+                },
+            },
+        ]);
+        codes.push(`;\n`);
+        codes.push(`export { default } from '${src}';\n`);
+    }
+    function generateScriptContentBeforeExportDefault() {
+        if (!script)
+            return;
+        if (!!scriptSetup && scriptRanges?.exportDefault) {
+            addVirtualCode('script', 0, scriptRanges.exportDefault.expression.start);
+        }
+        else {
+            let isExportRawObject = false;
+            if (scriptRanges?.exportDefault) {
+                isExportRawObject = script.content.substring(scriptRanges.exportDefault.expression.start, scriptRanges.exportDefault.expression.end).startsWith('{');
+            }
+            if (isExportRawObject && vueCompilerOptions.optionsWrapper.length === 2 && scriptRanges?.exportDefault) {
+                addVirtualCode('script', 0, scriptRanges.exportDefault.expression.start);
+                codes.push(vueCompilerOptions.optionsWrapper[0]);
+                {
+                    codes.push(['', 'script', scriptRanges.exportDefault.expression.start, {
+                            __hint: {
+                                setting: 'vue.inlayHints.optionsWrapper',
+                                label: vueCompilerOptions.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'),
+                            }
+                        }]);
+                    addVirtualCode('script', scriptRanges.exportDefault.expression.start, scriptRanges.exportDefault.expression.end);
+                    codes.push(['', 'script', scriptRanges.exportDefault.expression.end, {
+                            __hint: {
+                                setting: 'vue.inlayHints.optionsWrapper',
+                                label: vueCompilerOptions.optionsWrapper[1],
+                                tooltip: '',
+                            }
+                        }]);
+                }
+                codes.push(vueCompilerOptions.optionsWrapper[1]);
+                addVirtualCode('script', scriptRanges.exportDefault.expression.end, script.content.length);
+            }
+            else {
+                addVirtualCode('script', 0, script.content.length);
+            }
+        }
+    }
+    function generateScriptContentAfterExportDefault() {
+        if (!script)
+            return;
+        if (!!scriptSetup && scriptRanges?.exportDefault) {
+            addVirtualCode('script', scriptRanges.exportDefault.expression.end, script.content.length);
+        }
+    }
+    function generateScriptSetupImports() {
+        if (!scriptSetup)
+            return;
+        if (!scriptSetupRanges)
+            return;
+        codes.push([
+            scriptSetup.content.substring(0, Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset)) + '\n',
+            'scriptSetup',
+            0,
+            language_core_1.FileRangeCapabilities.full,
+        ]);
+    }
+    function generateScriptSetupAndTemplate() {
+        if (!scriptSetup || !scriptSetupRanges) {
+            return;
+        }
+        const definePropMirrors = {};
+        let scriptSetupGeneratedOffset;
+        if (scriptSetup.generic) {
+            if (!scriptRanges?.exportDefault) {
+                codes.push('export default ');
+            }
+            codes.push(`(<`);
+            codes.push([
+                scriptSetup.generic,
+                scriptSetup.name,
+                scriptSetup.genericOffset,
+                language_core_1.FileRangeCapabilities.full,
+            ]);
+            if (!scriptSetup.generic.endsWith(',')) {
+                codes.push(`,`);
+            }
+            codes.push(`>`);
+            codes.push('(\n');
+            codes.push(`__VLS_props: Awaited<typeof __VLS_setup>['props'],\n`);
+            codes.push(`__VLS_ctx?: __VLS_Prettify<Pick<Awaited<typeof __VLS_setup>, 'attrs' | 'emit' | 'slots'>>,\n`); // use __VLS_Prettify for less dts code
+            codes.push(`__VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>['expose'],\n`);
+            codes.push('__VLS_setup = (async () => {\n');
+            scriptSetupGeneratedOffset = generateSetupFunction(true, 'none', definePropMirrors);
+            //#region props
+            codes.push(`const __VLS_fnComponent = `);
+            codes.push(`(await import('${vueCompilerOptions.lib}')).defineComponent({\n`);
+            if (scriptSetupRanges.props.define?.arg) {
+                codes.push(`props: `);
+                addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.props.define.arg.start, scriptSetupRanges.props.define.arg.end);
+                codes.push(`,\n`);
+            }
+            if (scriptSetupRanges.emits.define) {
+                codes.push(`emits: ({} as __VLS_NormalizeEmits<typeof `, scriptSetupRanges.emits.name ?? '__VLS_emit', `>),\n`);
+            }
+            codes.push(`});\n`);
+            if (scriptSetupRanges.defineProp.length) {
+                codes.push(`const __VLS_defaults = {\n`);
+                for (const defineProp of scriptSetupRanges.defineProp) {
+                    if (defineProp.defaultValue) {
+                        if (defineProp.name) {
+                            codes.push(scriptSetup.content.substring(defineProp.name.start, defineProp.name.end));
+                        }
+                        else {
+                            codes.push('modelValue');
+                        }
+                        codes.push(`: `);
+                        codes.push(scriptSetup.content.substring(defineProp.defaultValue.start, defineProp.defaultValue.end));
+                        codes.push(`,\n`);
+                    }
+                }
+                codes.push(`};\n`);
+            }
+            codes.push(`let __VLS_fnPropsTypeOnly!: {}`); // TODO: reuse __VLS_fnPropsTypeOnly even without generic, and remove __VLS_propsOption_defineProp
+            if (scriptSetupRanges.props.define?.typeArg) {
+                codes.push(` & `);
+                addVirtualCode('scriptSetup', scriptSetupRanges.props.define.typeArg.start, scriptSetupRanges.props.define.typeArg.end);
+            }
+            if (scriptSetupRanges.defineProp.length) {
+                codes.push(` & {\n`);
+                for (const defineProp of scriptSetupRanges.defineProp) {
+                    let propName = 'modelValue';
+                    if (defineProp.name) {
+                        propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
+                        const propMirrorStart = muggle.getLength(codes);
+                        definePropMirrors[propName] = [propMirrorStart, propMirrorStart + propName.length];
+                    }
+                    codes.push(`${propName}${defineProp.required ? '' : '?'}: `);
+                    if (defineProp.type) {
+                        codes.push(scriptSetup.content.substring(defineProp.type.start, defineProp.type.end));
+                    }
+                    else if (defineProp.defaultValue) {
+                        codes.push(`typeof __VLS_defaults['`);
+                        codes.push(propName);
+                        codes.push(`']`);
+                    }
+                    else {
+                        codes.push(`any`);
+                    }
+                    codes.push(',\n');
+                }
+                codes.push(`}`);
+            }
+            codes.push(`;\n`);
+            codes.push(`let __VLS_fnPropsDefineComponent!: InstanceType<typeof __VLS_fnComponent>['$props']`);
+            codes.push(`;\n`);
+            codes.push(`let __VLS_fnPropsSlots!: `);
+            if (scriptSetupRanges.slots.define && vueCompilerOptions.jsxSlots) {
+                usedHelperTypes.PropsChildren = true;
+                codes.push(`__VLS_PropsChildren<typeof __VLS_slots>`);
+            }
+            else {
+                codes.push(`{}`);
+            }
+            codes.push(`;\n`);
+            codes.push(`let __VLS_defaultProps!: `, `import('${vueCompilerOptions.lib}').VNodeProps`, `& import('${vueCompilerOptions.lib}').AllowedComponentProps`, `& import('${vueCompilerOptions.lib}').ComponentCustomProps`, `;\n`);
+            //#endregion
+            codes.push('return {} as {\n');
+            codes.push(`props: __VLS_Prettify<__VLS_OmitKeepDiscriminatedUnion<typeof __VLS_fnPropsDefineComponent & typeof __VLS_fnPropsTypeOnly, keyof typeof __VLS_defaultProps>> & typeof __VLS_fnPropsSlots & typeof __VLS_defaultProps,\n`);
+            codes.push(`expose(exposed: import('${vueCompilerOptions.lib}').ShallowUnwrapRef<${scriptSetupRanges.expose.define ? 'typeof __VLS_exposed' : '{}'}>): void,\n`);
+            codes.push('attrs: any,\n');
+            codes.push('slots: ReturnType<typeof __VLS_template>,\n');
+            codes.push(`emit: typeof ${scriptSetupRanges.emits.name ?? '__VLS_emit'},\n`);
+            codes.push('};\n');
+            codes.push('})(),\n');
+            codes.push(`) => ({} as import('${vueCompilerOptions.lib}').VNode & { __ctx?: Awaited<typeof __VLS_setup> }))`);
+        }
+        else if (!script) {
+            // no script block, generate script setup code at root
+            scriptSetupGeneratedOffset = generateSetupFunction(false, 'export', definePropMirrors);
+        }
+        else {
+            if (!scriptRanges?.exportDefault) {
+                codes.push('export default ');
+            }
+            codes.push('await (async () => {\n');
+            scriptSetupGeneratedOffset = generateSetupFunction(false, 'return', definePropMirrors);
+            codes.push(`})()`);
+        }
+        if (scriptSetupGeneratedOffset !== undefined) {
+            for (const defineProp of scriptSetupRanges.defineProp) {
+                if (!defineProp.name) {
+                    continue;
+                }
+                const propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
+                const propMirror = definePropMirrors[propName];
+                if (propMirror) {
+                    mirrorBehaviorMappings.push({
+                        sourceRange: [defineProp.name.start + scriptSetupGeneratedOffset, defineProp.name.end + scriptSetupGeneratedOffset],
+                        generatedRange: propMirror,
+                        data: [
+                            language_core_1.MirrorBehaviorCapabilities.full,
+                            language_core_1.MirrorBehaviorCapabilities.full,
+                        ],
+                    });
+                }
+            }
+        }
+    }
+    function generateSetupFunction(functional, mode, definePropMirrors) {
+        if (!scriptSetupRanges || !scriptSetup) {
+            return;
+        }
+        const definePropProposalA = scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition') || vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';
+        const definePropProposalB = scriptSetup.content.trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition') || vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition';
+        if (vueCompilerOptions.target >= 3.3) {
+            codes.push('const { ');
+            for (const macro of Object.keys(vueCompilerOptions.macros)) {
+                if (!bindingNames.has(macro)) {
+                    codes.push(macro, ', ');
+                }
+            }
+            codes.push(`} = await import('${vueCompilerOptions.lib}');\n`);
+        }
+        if (definePropProposalA) {
+            codes.push(`
+declare function defineProp<T>(name: string, options: { required: true } & Record<string, unknown>): import('${vueCompilerOptions.lib}').ComputedRef<T>;
+declare function defineProp<T>(name: string, options: { default: any } & Record<string, unknown>): import('${vueCompilerOptions.lib}').ComputedRef<T>;
+declare function defineProp<T>(name?: string, options?: any): import('${vueCompilerOptions.lib}').ComputedRef<T | undefined>;
+`.trim() + '\n');
+        }
+        if (definePropProposalB) {
+            codes.push(`
+declare function defineProp<T>(value: T | (() => T), required?: boolean, rest?: any): import('${vueCompilerOptions.lib}').ComputedRef<T>;
+declare function defineProp<T>(value: T | (() => T) | undefined, required: true, rest?: any): import('${vueCompilerOptions.lib}').ComputedRef<T>;
+declare function defineProp<T>(value?: T | (() => T), required?: boolean, rest?: any): import('${vueCompilerOptions.lib}').ComputedRef<T | undefined>;
+`.trim() + '\n');
+        }
+        const scriptSetupGeneratedOffset = muggle.getLength(codes) - scriptSetupRanges.importSectionEndOffset;
+        let setupCodeModifies = [];
+        if (scriptSetupRanges.props.define && !scriptSetupRanges.props.name) {
+            const range = scriptSetupRanges.props.withDefaults ?? scriptSetupRanges.props.define;
+            const statement = scriptSetupRanges.props.define.statement;
+            if (statement.start === range.start && statement.end === range.end) {
+                setupCodeModifies.push([() => codes.push(`const __VLS_props = `), range.start, range.start]);
+            }
+            else {
+                setupCodeModifies.push([() => {
+                        codes.push(`const __VLS_props = `);
+                        addVirtualCode('scriptSetup', range.start, range.end);
+                        codes.push(`;\n`);
+                        addVirtualCode('scriptSetup', statement.start, range.start);
+                        codes.push(`__VLS_props`);
+                    }, statement.start, range.end]);
+            }
+        }
+        if (scriptSetupRanges.slots.define && !scriptSetupRanges.slots.name) {
+            setupCodeModifies.push([() => codes.push(`const __VLS_slots = `), scriptSetupRanges.slots.define.start, scriptSetupRanges.slots.define.start]);
+        }
+        if (scriptSetupRanges.emits.define && !scriptSetupRanges.emits.name) {
+            setupCodeModifies.push([() => codes.push(`const __VLS_emit = `), scriptSetupRanges.emits.define.start, scriptSetupRanges.emits.define.start]);
+        }
+        if (scriptSetupRanges.expose.define) {
+            setupCodeModifies.push([() => {
+                    if (scriptSetupRanges?.expose.define?.typeArg) {
+                        codes.push(`let __VLS_exposed!: `);
+                        addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.expose.define.typeArg.start, scriptSetupRanges.expose.define.typeArg.end);
+                        codes.push(`;\n`);
+                    }
+                    else if (scriptSetupRanges?.expose.define?.arg) {
+                        codes.push(`const __VLS_exposed = `);
+                        addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.expose.define.arg.start, scriptSetupRanges.expose.define.arg.end);
+                        codes.push(`;\n`);
+                    }
+                    else {
+                        codes.push(`const __VLS_exposed = {};\n`);
+                    }
+                }, scriptSetupRanges.expose.define.start, scriptSetupRanges.expose.define.start]);
+        }
+        setupCodeModifies = setupCodeModifies.sort((a, b) => a[1] - b[1]);
+        if (setupCodeModifies.length) {
+            addVirtualCode('scriptSetup', scriptSetupRanges.importSectionEndOffset, setupCodeModifies[0][1]);
+            while (setupCodeModifies.length) {
+                const [generate, _, end] = setupCodeModifies.shift();
+                generate();
+                if (setupCodeModifies.length) {
+                    const nextStart = setupCodeModifies[0][1];
+                    addVirtualCode('scriptSetup', end, nextStart);
+                }
+                else {
+                    addVirtualCode('scriptSetup', end);
+                }
+            }
+        }
+        else {
+            addVirtualCode('scriptSetup', scriptSetupRanges.importSectionEndOffset);
+        }
+        if (scriptSetupRanges.props.define?.typeArg && scriptSetupRanges.props.withDefaults?.arg) {
+            // fix https://github.com/vuejs/language-tools/issues/1187
+            codes.push(`const __VLS_withDefaultsArg = (function <T>(t: T) { return t })(`);
+            addExtraReferenceVirtualCode('scriptSetup', scriptSetupRanges.props.withDefaults.arg.start, scriptSetupRanges.props.withDefaults.arg.end);
+            codes.push(`);\n`);
+        }
+        if (!functional && scriptSetupRanges.defineProp.length) {
+            codes.push(`let __VLS_propsOption_defineProp!: {\n`);
+            for (const defineProp of scriptSetupRanges.defineProp) {
+                let propName = 'modelValue';
+                if (defineProp.name && defineProp.nameIsString) {
+                    // renaming support
+                    addExtraReferenceVirtualCode('scriptSetup', defineProp.name.start, defineProp.name.end);
+                }
+                else if (defineProp.name) {
+                    propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
+                    const start = muggle.getLength(codes);
+                    definePropMirrors[propName] = [start, start + propName.length];
+                    codes.push(propName);
+                }
+                else {
+                    codes.push(propName);
+                }
+                codes.push(`: `);
+                let type = 'any';
+                if (!defineProp.nameIsString) {
+                    type = `NonNullable<typeof ${propName}['value']>`;
+                }
+                else if (defineProp.type) {
+                    type = scriptSetup.content.substring(defineProp.type.start, defineProp.type.end);
+                }
+                if (defineProp.required) {
+                    codes.push(`{ required: true, type: import('${vueCompilerOptions.lib}').PropType<${type}> },\n`);
+                }
+                else {
+                    codes.push(`import('${vueCompilerOptions.lib}').PropType<${type}>,\n`);
+                }
+            }
+            codes.push(`};\n`);
+        }
+        generateTemplate(functional);
+        if (mode === 'return' || mode === 'export') {
+            if (!vueCompilerOptions.skipTemplateCodegen && (htmlGen?.hasSlot || scriptSetupRanges?.slots.define)) {
+                usedHelperTypes.WithTemplateSlots = true;
+                codes.push(`const __VLS_component = `);
+                generateComponent(functional);
+                codes.push(`;\n`);
+                codes.push(mode === 'return' ? 'return ' : 'export default ');
+                codes.push(`{} as __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;\n`);
+            }
+            else {
+                codes.push(mode === 'return' ? 'return ' : 'export default ');
+                generateComponent(functional);
+                codes.push(`;\n`);
+            }
+        }
+        return scriptSetupGeneratedOffset;
+    }
+    function generateComponent(functional) {
+        if (!scriptSetupRanges)
+            return;
+        if (scriptRanges?.exportDefault && scriptRanges.exportDefault.expression.start !== scriptRanges.exportDefault.args.start) {
+            // use defineComponent() from user space code if it exist
+            addVirtualCode('script', scriptRanges.exportDefault.expression.start, scriptRanges.exportDefault.args.start);
+            codes.push(`{\n`);
+        }
+        else {
+            codes.push(`(await import('${vueCompilerOptions.lib}')).defineComponent({\n`);
+        }
+        codes.push(`setup() {\n`);
+        codes.push(`return {\n`);
+        generateSetupReturns();
+        if (scriptSetupRanges.expose.define) {
+            codes.push(`...__VLS_exposed,\n`);
+        }
+        codes.push(`};\n`);
+        codes.push(`},\n`);
+        generateComponentOptions(functional);
+        codes.push(`})`);
+    }
+    function generateComponentOptions(functional) {
+        if (scriptSetupRanges && !bypassDefineComponent) {
+            const ranges = scriptSetupRanges;
+            const propsCodegens = [];
+            if (ranges.props.define?.arg) {
+                const arg = ranges.props.define.arg;
+                propsCodegens.push(() => {
+                    addExtraReferenceVirtualCode('scriptSetup', arg.start, arg.end);
+                });
+            }
+            if (ranges.props.define?.typeArg) {
+                const typeArg = ranges.props.define.typeArg;
+                propsCodegens.push(() => {
+                    usedHelperTypes.DefinePropsToOptions = true;
+                    codes.push(`{} as `);
+                    if (ranges.props.withDefaults?.arg) {
+                        usedHelperTypes.MergePropDefaults = true;
+                        codes.push(`__VLS_WithDefaults<`);
+                    }
+                    codes.push(`__VLS_TypePropsToRuntimeProps<`);
+                    if (functional) {
+                        codes.push(`typeof __VLS_fnPropsTypeOnly`);
+                    }
+                    else {
+                        addExtraReferenceVirtualCode('scriptSetup', typeArg.start, typeArg.end);
+                    }
+                    codes.push(`>`);
+                    if (ranges.props.withDefaults?.arg) {
+                        codes.push(`, typeof __VLS_withDefaultsArg`);
+                        codes.push(`>`);
+                    }
+                });
+            }
+            if (!functional && ranges.defineProp.length) {
+                propsCodegens.push(() => {
+                    codes.push(`__VLS_propsOption_defineProp`);
+                });
+            }
+            if (propsCodegens.length === 1) {
+                codes.push(`props: `);
+                for (const generate of propsCodegens) {
+                    generate();
+                }
+                codes.push(`,\n`);
+            }
+            else if (propsCodegens.length >= 2) {
+                codes.push(`props: {\n`);
+                for (const generate of propsCodegens) {
+                    codes.push('...');
+                    generate();
+                    codes.push(',\n');
+                }
+                codes.push(`},\n`);
+            }
+            if (ranges.emits.define) {
+                codes.push(`emits: ({} as __VLS_NormalizeEmits<typeof `, ranges.emits.name ?? '__VLS_emit', `>),\n`);
+            }
+        }
+        if (scriptRanges?.exportDefault?.args) {
+            addVirtualCode('script', scriptRanges.exportDefault.args.start + 1, scriptRanges.exportDefault.args.end - 1);
+        }
+    }
+    function generateSetupReturns() {
+        if (scriptSetupRanges && bypassDefineComponent) {
+            // fill $props
+            if (scriptSetupRanges.props.define) {
+                // NOTE: defineProps is inaccurate for $props
+                codes.push(`$props: __VLS_makeOptional(${scriptSetupRanges.props.name ?? `__VLS_props`}),\n`);
+                codes.push(`...${scriptSetupRanges.props.name ?? `__VLS_props`},\n`);
+            }
+            // fill $emit
+            if (scriptSetupRanges.emits.define) {
+                codes.push(`$emit: ${scriptSetupRanges.emits.name ?? '__VLS_emit'},\n`);
+            }
+        }
+    }
+    function generateTemplate(functional) {
+        generatedTemplate = true;
+        if (!vueCompilerOptions.skipTemplateCodegen) {
+            generateExportOptions();
+            generateConstNameOption();
+            codes.push(`function __VLS_template() {\n`);
+            const templateGened = generateTemplateContext();
+            codes.push(`}\n`);
+            generateComponentForTemplateUsage(functional, templateGened.cssIds);
+        }
+        else {
+            codes.push(`function __VLS_template() {\n`);
+            const templateUsageVars = [...getTemplateUsageVars()];
+            codes.push(`// @ts-ignore\n`);
+            codes.push(`[${templateUsageVars.join(', ')}]\n`);
+            codes.push(`return {};\n`);
+            codes.push(`}\n`);
+        }
+    }
+    function generateComponentForTemplateUsage(functional, cssIds) {
+        if (scriptSetup && scriptSetupRanges) {
+            codes.push(`const __VLS_internalComponent = (await import('${vueCompilerOptions.lib}')).defineComponent({\n`);
+            codes.push(`setup() {\n`);
+            codes.push(`return {\n`);
+            generateSetupReturns();
+            // bindings
+            const templateUsageVars = getTemplateUsageVars();
+            for (const [content, bindings] of [
+                [scriptSetup.content, scriptSetupRanges.bindings],
+                scriptRanges && script
+                    ? [script.content, scriptRanges.bindings]
+                    : ['', []],
+            ]) {
+                for (const expose of bindings) {
+                    const varName = content.substring(expose.start, expose.end);
+                    if (!templateUsageVars.has(varName) && !cssIds.has(varName)) {
+                        continue;
+                    }
+                    const templateStart = (0, source_map_1.getLength)(codes);
+                    codes.push(varName);
+                    const templateEnd = (0, source_map_1.getLength)(codes);
+                    codes.push(`: ${varName} as typeof `);
+                    const scriptStart = (0, source_map_1.getLength)(codes);
+                    codes.push(varName);
+                    const scriptEnd = (0, source_map_1.getLength)(codes);
+                    codes.push(',\n');
+                    mirrorBehaviorMappings.push({
+                        sourceRange: [scriptStart, scriptEnd],
+                        generatedRange: [templateStart, templateEnd],
+                        data: [
+                            language_core_1.MirrorBehaviorCapabilities.full,
+                            language_core_1.MirrorBehaviorCapabilities.full,
+                        ],
+                    });
+                }
+            }
+            codes.push(`};\n`); // return {
+            codes.push(`},\n`); // setup() {
+            generateComponentOptions(functional);
+            codes.push(`});\n`); // defineComponent({
+        }
+        else if (script) {
+            codes.push(`let __VLS_internalComponent!: typeof import('./${path.basename(fileName)}')['default'];\n`);
+        }
+        else {
+            codes.push(`const __VLS_internalComponent = (await import('${vueCompilerOptions.lib}')).defineComponent({});\n`);
+        }
+    }
+    function generateExportOptions() {
+        codes.push(`\n`);
+        codes.push(`const __VLS_componentsOption = `);
+        if (script && scriptRanges?.exportDefault?.componentsOption) {
+            const componentsOption = scriptRanges.exportDefault.componentsOption;
+            codes.push([
+                script.content.substring(componentsOption.start, componentsOption.end),
+                'script',
+                componentsOption.start,
+                {
+                    references: true,
+                    rename: true,
+                },
+            ]);
+        }
+        else {
+            codes.push('{}');
+        }
+        codes.push(`;\n`);
+    }
+    function generateConstNameOption() {
+        codes.push(`\n`);
+        if (script && scriptRanges?.exportDefault?.nameOption) {
+            const nameOption = scriptRanges.exportDefault.nameOption;
+            codes.push(`const __VLS_name = `);
+            codes.push(`${script.content.substring(nameOption.start, nameOption.end)} as const`);
+            codes.push(`;\n`);
+        }
+        else if (scriptSetup) {
+            codes.push(`let __VLS_name!: '${path.basename(fileName.substring(0, fileName.lastIndexOf('.')))}';\n`);
+        }
+        else {
+            codes.push(`const __VLS_name = undefined;\n`);
+        }
+    }
+    function generateTemplateContext() {
+        const useGlobalThisTypeInCtx = fileName.endsWith('.html');
+        codes.push(`let __VLS_ctx!: ${useGlobalThisTypeInCtx ? 'typeof globalThis &' : ''}`);
+        codes.push(`InstanceType<__VLS_PickNotAny<typeof __VLS_internalComponent, new () => {}>> & {\n`);
+        /* CSS Module */
+        for (let i = 0; i < styles.length; i++) {
+            const style = styles[i];
+            if (style.module) {
+                codes.push(`${style.module}: Record<string, string> & __VLS_Prettify<{}`);
+                for (const className of style.classNames) {
+                    generateCssClassProperty(i, className.text.substring(1), { start: className.offset, end: className.offset + className.text.length }, 'string', false, true);
+                }
+                codes.push('>;\n');
+            }
+        }
+        codes.push(`};\n`);
+        /* Components */
+        codes.push('/* Components */\n');
+        codes.push(`let __VLS_otherComponents!: NonNullable<typeof __VLS_internalComponent extends { components: infer C } ? C : {}> & typeof __VLS_componentsOption;\n`);
+        codes.push(`let __VLS_own!: __VLS_SelfComponent<typeof __VLS_name, typeof __VLS_internalComponent & (new () => { ${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: typeof ${scriptSetupRanges?.slots?.name ?? '__VLS_slots'} })>;\n`);
+        codes.push(`let __VLS_localComponents!: typeof __VLS_otherComponents & Omit<typeof __VLS_own, keyof typeof __VLS_otherComponents>;\n`);
+        codes.push(`let __VLS_components!: typeof __VLS_localComponents & __VLS_GlobalComponents & typeof __VLS_ctx;\n`); // for html completion, TS references...
+        /* Style Scoped */
+        codes.push('/* Style Scoped */\n');
+        codes.push('type __VLS_StyleScopedClasses = {}');
+        for (let i = 0; i < styles.length; i++) {
+            const style = styles[i];
+            const option = vueCompilerOptions.experimentalResolveStyleCssClasses;
+            if (option === 'always' || (option === 'scoped' && style.scoped)) {
+                for (const className of style.classNames) {
+                    generateCssClassProperty(i, className.text.substring(1), { start: className.offset, end: className.offset + className.text.length }, 'boolean', true, !style.module);
+                }
+            }
+        }
+        codes.push(';\n');
+        codes.push('let __VLS_styleScopedClasses!: __VLS_StyleScopedClasses | keyof __VLS_StyleScopedClasses | (keyof __VLS_StyleScopedClasses)[];\n');
+        codes.push(`/* CSS variable injection */\n`);
+        const cssIds = generateCssVars();
+        codes.push(`/* CSS variable injection end */\n`);
+        if (htmlGen) {
+            muggle.setTracking(false);
+            for (const s of htmlGen.codes) {
+                codes.push(s);
+            }
+            muggle.setTracking(true);
+            for (const s of htmlGen.codeStacks) {
+                codeStacks.push(s);
+            }
+        }
+        if (!htmlGen) {
+            codes.push(`// no template\n`);
+            if (!scriptSetupRanges?.slots.define) {
+                codes.push(`const __VLS_slots = {};\n`);
+            }
+        }
+        codes.push(`return ${scriptSetupRanges?.slots.name ?? '__VLS_slots'};\n`);
+        return { cssIds };
+        function generateCssClassProperty(styleIndex, className, classRange, propertyType, optional, referencesCodeLens) {
+            codes.push(`\n & { `);
+            codes.push([
+                '',
+                'style_' + styleIndex,
+                classRange.start,
+                {
+                    references: true,
+                    referencesCodeLens,
+                },
+            ]);
+            codes.push(`'`);
+            codes.push([
+                className,
+                'style_' + styleIndex,
+                [classRange.start, classRange.end],
+                {
+                    references: true,
+                    rename: {
+                        normalize: normalizeCssRename,
+                        apply: applyCssRename,
+                    },
+                },
+            ]);
+            codes.push(`'`);
+            codes.push([
+                '',
+                'style_' + styleIndex,
+                classRange.end,
+                {},
+            ]);
+            codes.push(`${optional ? '?' : ''}: ${propertyType}`);
+            codes.push(` }`);
+        }
+        function generateCssVars() {
+            const emptyLocalVars = new Map();
+            const identifiers = new Set();
+            for (const style of styles) {
+                for (const cssBind of style.cssVars) {
+                    (0, transform_1.walkInterpolationFragment)(ts, cssBind.text, ts.createSourceFile('/a.txt', cssBind.text, ts.ScriptTarget.ESNext), (frag, fragOffset, onlyForErrorMapping) => {
+                        if (fragOffset === undefined) {
+                            codes.push(frag);
+                        }
+                        else {
+                            codes.push([
+                                frag,
+                                style.name,
+                                cssBind.offset + fragOffset,
+                                onlyForErrorMapping
+                                    ? { diagnostic: true }
+                                    : language_core_1.FileRangeCapabilities.full,
+                            ]);
+                        }
+                    }, emptyLocalVars, identifiers, vueCompilerOptions);
+                    codes.push(';\n');
+                }
+            }
+            return identifiers;
+        }
+    }
+    function getTemplateUsageVars() {
+        const usageVars = new Set();
+        if (htmlGen) {
+            // fix import components unused report
+            for (const varName of bindingNames) {
+                if (!!htmlGen.tagNames[varName] || !!htmlGen.tagNames[(0, shared_1.hyphenateTag)(varName)]) {
+                    usageVars.add(varName);
+                }
+            }
+            for (const tag of Object.keys(htmlGen.tagNames)) {
+                if (tag.indexOf('.') >= 0) {
+                    usageVars.add(tag.split('.')[0]);
+                }
+            }
+            for (const _id of htmlGen.accessedGlobalVariables) {
+                usageVars.add(_id);
+            }
+        }
+        return usageVars;
+    }
+    function addVirtualCode(vueTag, start, end) {
+        muggle.offsetStack();
+        codes.push([
+            (vueTag === 'script' ? script : scriptSetup).content.substring(start, end),
+            vueTag,
+            start,
+            language_core_1.FileRangeCapabilities.full, // diagnostic also working for setup() returns unused in template checking
+        ]);
+        muggle.resetOffsetStack();
+    }
+    function addExtraReferenceVirtualCode(vueTag, start, end) {
+        muggle.offsetStack();
+        codes.push([
+            (vueTag === 'script' ? script : scriptSetup).content.substring(start, end),
+            vueTag,
+            start,
+            {
+                references: true,
+                definition: true,
+                rename: true,
+            },
+        ]);
+        muggle.resetOffsetStack();
+    }
+}
+exports.generate = generate;
+function normalizeCssRename(newName) {
+    return newName.startsWith('.') ? newName.slice(1) : newName;
+}
+function applyCssRename(newName) {
+    return '.' + newName;
+}
+//# sourceMappingURL=script.js.map

node_modules/@vue/language-core/out/generators/template.d.ts

@@ -0,0 +1,21 @@
+import { FileRangeCapabilities } from '@volar/language-core';
+import { Segment } from '@volar/source-map';
+import * as CompilerDOM from '@vue/compiler-dom';
+import * as muggle from 'muggle-string';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { Sfc, VueCompilerOptions } from '../types';
+type Code = Segment<FileRangeCapabilities>;
+export declare function generate(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, template: NonNullable<Sfc['template']>, shouldGenerateScopedClasses: boolean, stylesScopedClasses: Set<string>, hasScriptSetupSlots: boolean, slotsAssignName: string | undefined, propsAssignName: string | undefined, codegenStack: boolean): {
+    codes: Code[];
+    codeStacks: muggle.StackNode[];
+    formatCodes: Code[];
+    formatCodeStacks: muggle.StackNode[];
+    cssCodes: Code[];
+    cssCodeStacks: muggle.StackNode[];
+    tagNames: Record<string, number[]>;
+    accessedGlobalVariables: Set<string>;
+    hasSlot: boolean;
+};
+export declare function walkElementNodes(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode, cb: (node: CompilerDOM.ElementNode) => void): void;
+export {};
+//# sourceMappingURL=template.d.ts.map

node_modules/@vue/language-core/out/index.d.ts

@@ -0,0 +1,16 @@
+export * from './generators/template';
+export * from './languageModule';
+export * from './parsers/scriptSetupRanges';
+export * from './plugins';
+export * from './virtualFile/vueFile';
+export * from './types';
+export * from './utils/ts';
+export * from './utils/parseSfc';
+export * as scriptRanges from './parsers/scriptRanges';
+export * as sharedTypes from './utils/globalTypes';
+export * from './utils/shared';
+export { tsCodegen } from './plugins/vue-tsx';
+export * from '@volar/language-core';
+export * from '@volar/source-map';
+export type * as CompilerDOM from '@vue/compiler-dom';
+//# sourceMappingURL=index.d.ts.map

node_modules/@vue/language-core/out/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsCodegen = exports.sharedTypes = exports.scriptRanges = void 0;
+__exportStar(require("./generators/template"), exports);
+__exportStar(require("./languageModule"), exports);
+__exportStar(require("./parsers/scriptSetupRanges"), exports);
+__exportStar(require("./plugins"), exports);
+__exportStar(require("./virtualFile/vueFile"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils/ts"), exports);
+__exportStar(require("./utils/parseSfc"), exports);
+exports.scriptRanges = require("./parsers/scriptRanges");
+exports.sharedTypes = require("./utils/globalTypes");
+__exportStar(require("./utils/shared"), exports);
+var vue_tsx_1 = require("./plugins/vue-tsx");
+Object.defineProperty(exports, "tsCodegen", { enumerable: true, get: function () { return vue_tsx_1.tsCodegen; } });
+__exportStar(require("@volar/language-core"), exports);
+__exportStar(require("@volar/source-map"), exports);
+//# sourceMappingURL=index.js.map

node_modules/@vue/language-core/out/languageModule.d.ts

@@ -0,0 +1,10 @@
+import type { Language } from '@volar/language-core';
+import { VueFile } from './virtualFile/vueFile';
+import { VueCompilerOptions } from './types';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function createVueLanguage(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions?: ts.CompilerOptions, _vueCompilerOptions?: Partial<VueCompilerOptions>, codegenStack?: boolean): Language<VueFile>;
+/**
+ * @deprecated planed to remove in 2.0, please use createVueLanguage instead of
+ */
+export declare function createLanguages(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions?: ts.CompilerOptions, vueCompilerOptions?: Partial<VueCompilerOptions>, codegenStack?: boolean): Language[];
+//# sourceMappingURL=languageModule.d.ts.map

node_modules/@vue/language-core/out/languageModule.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguages = exports.createVueLanguage = void 0;
+const path = require("path-browserify");
+const plugins_1 = require("./plugins");
+const vueFile_1 = require("./virtualFile/vueFile");
+const sharedTypes = require("./utils/globalTypes");
+const ts_1 = require("./utils/ts");
+const fileRegistries = [];
+function getVueFileRegistry(key, plugins) {
+    let fileRegistry = fileRegistries.find(r => r.key === key
+        && r.plugins.length === plugins.length
+        && r.plugins.every(plugin => plugins.includes(plugin)))?.files;
+    if (!fileRegistry) {
+        fileRegistry = new Map();
+        fileRegistries.push({
+            key: key,
+            plugins: plugins,
+            files: fileRegistry,
+        });
+    }
+    return fileRegistry;
+}
+function createVueLanguage(ts, compilerOptions = {}, _vueCompilerOptions = {}, codegenStack = false) {
+    const vueCompilerOptions = (0, ts_1.resolveVueCompilerOptions)(_vueCompilerOptions);
+    const plugins = (0, plugins_1.getDefaultVueLanguagePlugins)(ts, compilerOptions, vueCompilerOptions, codegenStack);
+    const keys = [
+        ...Object.keys(vueCompilerOptions)
+            .sort()
+            .filter(key => key !== 'plugins')
+            .map(key => [key, vueCompilerOptions[key]]),
+        [...new Set(plugins.map(plugin => plugin.requiredCompilerOptions ?? []).flat())]
+            .sort()
+            .map(key => [key, compilerOptions[key]]),
+    ];
+    const fileRegistry = getVueFileRegistry(JSON.stringify(keys), _vueCompilerOptions.plugins ?? []);
+    const allowLanguageIds = new Set(['vue']);
+    if (vueCompilerOptions.extensions.includes('.md')) {
+        allowLanguageIds.add('markdown');
+    }
+    if (vueCompilerOptions.extensions.includes('.html')) {
+        allowLanguageIds.add('html');
+    }
+    return {
+        createVirtualFile(fileName, snapshot, languageId) {
+            if ((languageId && allowLanguageIds.has(languageId))
+                || (!languageId && vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext)))) {
+                if (fileRegistry.has(fileName)) {
+                    const reusedVueFile = fileRegistry.get(fileName);
+                    reusedVueFile.update(snapshot);
+                    return reusedVueFile;
+                }
+                const vueFile = new vueFile_1.VueFile(fileName, snapshot, vueCompilerOptions, plugins, ts, codegenStack);
+                fileRegistry.set(fileName, vueFile);
+                return vueFile;
+            }
+        },
+        updateVirtualFile(sourceFile, snapshot) {
+            sourceFile.update(snapshot);
+        },
+        resolveHost(host) {
+            const sharedTypesSnapshot = ts.ScriptSnapshot.fromString(sharedTypes.getTypesCode(vueCompilerOptions));
+            const sharedTypesFileName = path.join(host.rootPath, sharedTypes.baseName);
+            return {
+                ...host,
+                resolveModuleName(moduleName, impliedNodeFormat) {
+                    if (impliedNodeFormat === ts.ModuleKind.ESNext && vueCompilerOptions.extensions.some(ext => moduleName.endsWith(ext))) {
+                        return `${moduleName}.js`;
+                    }
+                    return host.resolveModuleName?.(moduleName, impliedNodeFormat) ?? moduleName;
+                },
+                getScriptFileNames() {
+                    return [
+                        sharedTypesFileName,
+                        ...host.getScriptFileNames(),
+                    ];
+                },
+                getScriptSnapshot(fileName) {
+                    if (fileName === sharedTypesFileName) {
+                        return sharedTypesSnapshot;
+                    }
+                    return host.getScriptSnapshot(fileName);
+                },
+            };
+        },
+    };
+}
+exports.createVueLanguage = createVueLanguage;
+/**
+ * @deprecated planed to remove in 2.0, please use createVueLanguage instead of
+ */
+function createLanguages(ts, compilerOptions = {}, vueCompilerOptions = {}, codegenStack = false) {
+    return [
+        createVueLanguage(ts, compilerOptions, vueCompilerOptions, codegenStack),
+        ...vueCompilerOptions.experimentalAdditionalLanguageModules?.map(module => require(module)) ?? [],
+    ];
+}
+exports.createLanguages = createLanguages;
+//# sourceMappingURL=languageModule.js.map

node_modules/@vue/language-core/out/parsers/scriptRanges.d.ts

@@ -0,0 +1,16 @@
+import type { TextRange } from '../types';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
+}
+export declare function parseScriptRanges(ts: typeof import('typescript/lib/tsserverlibrary'), ast: ts.SourceFile, hasScriptSetup: boolean, withNode: boolean): {
+    exportDefault: (TextRange & {
+        expression: TextRange;
+        args: TextRange;
+        argsNode: ts.ObjectLiteralExpression | undefined;
+        componentsOption: TextRange | undefined;
+        componentsOptionNode: ts.ObjectLiteralExpression | undefined;
+        nameOption: TextRange | undefined;
+    }) | undefined;
+    bindings: TextRange[];
+};
+//# sourceMappingURL=scriptRanges.d.ts.map

node_modules/@vue/language-core/out/parsers/scriptRanges.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseScriptRanges = void 0;
+const scriptSetupRanges_1 = require("./scriptSetupRanges");
+function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
+    let exportDefault;
+    const bindings = hasScriptSetup ? (0, scriptSetupRanges_1.parseBindingRanges)(ts, ast) : [];
+    ast.forEachChild(raw => {
+        if (ts.isExportAssignment(raw)) {
+            let node = raw;
+            while (ts.isAsExpression(node.expression) || ts.isParenthesizedExpression(node.expression)) { // fix https://github.com/vuejs/language-tools/issues/1882
+                node = node.expression;
+            }
+            let obj;
+            if (ts.isObjectLiteralExpression(node.expression)) {
+                obj = node.expression;
+            }
+            else if (ts.isCallExpression(node.expression) && node.expression.arguments.length) {
+                const arg0 = node.expression.arguments[0];
+                if (ts.isObjectLiteralExpression(arg0)) {
+                    obj = arg0;
+                }
+            }
+            if (obj) {
+                let componentsOptionNode;
+                let nameOptionNode;
+                obj.forEachChild(node => {
+                    if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
+                        if (node.name.escapedText === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
+                            componentsOptionNode = node.initializer;
+                        }
+                        if (node.name.escapedText === 'name') {
+                            nameOptionNode = node.initializer;
+                        }
+                    }
+                });
+                exportDefault = {
+                    ..._getStartEnd(raw),
+                    expression: _getStartEnd(node.expression),
+                    args: _getStartEnd(obj),
+                    argsNode: withNode ? obj : undefined,
+                    componentsOption: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
+                    componentsOptionNode: withNode ? componentsOptionNode : undefined,
+                    nameOption: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
+                };
+            }
+        }
+    });
+    return {
+        exportDefault,
+        bindings,
+    };
+    function _getStartEnd(node) {
+        return (0, scriptSetupRanges_1.getStartEnd)(node, ast);
+    }
+}
+exports.parseScriptRanges = parseScriptRanges;
+//# sourceMappingURL=scriptRanges.js.map

node_modules/@vue/language-core/out/parsers/scriptSetupRanges.d.ts

@@ -0,0 +1,56 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type { VueCompilerOptions, TextRange } from '../types';
+export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRanges> {
+}
+export declare function parseScriptSetupRanges(ts: typeof import('typescript/lib/tsserverlibrary'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
+    leadingCommentEndOffset: number;
+    importSectionEndOffset: number;
+    bindings: TextRange[];
+    props: {
+        name?: string | undefined;
+        define?: (TextRange & {
+            arg?: TextRange | undefined;
+            typeArg?: TextRange | undefined;
+        } & {
+            statement: TextRange;
+        }) | undefined;
+        withDefaults?: (TextRange & {
+            arg?: TextRange | undefined;
+        }) | undefined;
+    };
+    slots: {
+        name?: string | undefined;
+        define?: (TextRange & {
+            arg?: TextRange | undefined;
+            typeArg?: TextRange | undefined;
+        }) | undefined;
+    };
+    emits: {
+        name?: string | undefined;
+        define?: (TextRange & {
+            arg?: TextRange | undefined;
+            typeArg?: TextRange | undefined;
+        }) | undefined;
+    };
+    expose: {
+        name?: string | undefined;
+        define?: (TextRange & {
+            arg?: TextRange | undefined;
+            typeArg?: TextRange | undefined;
+        }) | undefined;
+    };
+    defineProp: {
+        name: TextRange | undefined;
+        nameIsString: boolean;
+        type: TextRange | undefined;
+        defaultValue: TextRange | undefined;
+        required: boolean;
+    }[];
+};
+export declare function parseBindingRanges(ts: typeof import('typescript/lib/tsserverlibrary'), sourceFile: ts.SourceFile): TextRange[];
+export declare function findBindingVars(ts: typeof import('typescript/lib/tsserverlibrary'), left: ts.BindingName, sourceFile: ts.SourceFile): TextRange[];
+export declare function getStartEnd(node: ts.Node, sourceFile: ts.SourceFile): {
+    start: number;
+    end: number;
+};
+//# sourceMappingURL=scriptSetupRanges.d.ts.map

node_modules/@vue/language-core/out/parsers/scriptSetupRanges.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStartEnd = exports.findBindingVars = exports.parseBindingRanges = exports.parseScriptSetupRanges = void 0;
+function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
+    let foundNonImportExportNode = false;
+    let importSectionEndOffset = 0;
+    const props = {};
+    const slots = {};
+    const emits = {};
+    const expose = {};
+    const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition' || ast.getFullText().trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition');
+    const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition' || ast.getFullText().trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition');
+    const defineProp = [];
+    const bindings = parseBindingRanges(ts, ast);
+    const text = ast.getFullText();
+    const leadingCommentEndOffset = ts.getLeadingCommentRanges(text, 0)?.reverse()[0].end ?? 0;
+    ast.forEachChild(node => {
+        const isTypeExport = (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) && node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
+        if (!foundNonImportExportNode
+            && !ts.isImportDeclaration(node)
+            && !isTypeExport
+            && !ts.isEmptyStatement(node)
+            // fix https://github.com/vuejs/language-tools/issues/1223
+            && !ts.isImportEqualsDeclaration(node)) {
+            const commentRanges = ts.getLeadingCommentRanges(text, node.getFullStart());
+            if (commentRanges?.length) {
+                const commentRange = commentRanges.sort((a, b) => a.pos - b.pos)[0];
+                importSectionEndOffset = commentRange.pos;
+            }
+            else {
+                importSectionEndOffset = node.getStart(ast);
+            }
+            foundNonImportExportNode = true;
+        }
+    });
+    ast.forEachChild(child => visitNode(child, [ast]));
+    return {
+        leadingCommentEndOffset,
+        importSectionEndOffset,
+        bindings,
+        props,
+        slots,
+        emits,
+        expose,
+        defineProp,
+    };
+    function _getStartEnd(node) {
+        return getStartEnd(node, ast);
+    }
+    function parseDefineFunction(node) {
+        return {
+            ..._getStartEnd(node),
+            arg: node.arguments.length ? _getStartEnd(node.arguments[0]) : undefined,
+            typeArg: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+        };
+    }
+    function visitNode(node, parents) {
+        const parent = parents[parents.length - 1];
+        if (ts.isCallExpression(node)
+            && ts.isIdentifier(node.expression)) {
+            const callText = node.expression.getText(ast);
+            if (vueCompilerOptions.macros.defineModel.includes(callText)) {
+                let name;
+                let options;
+                if (node.arguments.length >= 2) {
+                    name = _getStartEnd(node.arguments[0]);
+                    options = node.arguments[1];
+                }
+                else if (node.arguments.length >= 1) {
+                    if (ts.isStringLiteral(node.arguments[0])) {
+                        name = _getStartEnd(node.arguments[0]);
+                    }
+                    else {
+                        options = node.arguments[0];
+                    }
+                }
+                let required = false;
+                if (options && ts.isObjectLiteralExpression(options)) {
+                    for (const property of options.properties) {
+                        if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.getText(ast) === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                            required = true;
+                            break;
+                        }
+                    }
+                }
+                defineProp.push({
+                    name,
+                    nameIsString: true,
+                    type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                    defaultValue: undefined,
+                    required,
+                });
+            }
+            else if (callText === 'defineProp') {
+                if (definePropProposalA) {
+                    let required = false;
+                    if (node.arguments.length >= 2) {
+                        const secondArg = node.arguments[1];
+                        if (ts.isObjectLiteralExpression(secondArg)) {
+                            for (const property of secondArg.properties) {
+                                if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.getText(ast) === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                                    required = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (node.arguments.length >= 1) {
+                        defineProp.push({
+                            name: _getStartEnd(node.arguments[0]),
+                            nameIsString: true,
+                            type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                            defaultValue: undefined,
+                            required,
+                        });
+                    }
+                    else if (ts.isVariableDeclaration(parent)) {
+                        defineProp.push({
+                            name: _getStartEnd(parent.name),
+                            nameIsString: false,
+                            type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                            defaultValue: undefined,
+                            required,
+                        });
+                    }
+                }
+                else if (definePropProposalB && ts.isVariableDeclaration(parent)) {
+                    defineProp.push({
+                        name: _getStartEnd(parent.name),
+                        nameIsString: false,
+                        defaultValue: node.arguments.length >= 1 ? _getStartEnd(node.arguments[0]) : undefined,
+                        type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                        required: node.arguments.length >= 2 && node.arguments[1].kind === ts.SyntaxKind.TrueKeyword,
+                    });
+                }
+            }
+            else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
+                slots.define = parseDefineFunction(node);
+                if (ts.isVariableDeclaration(parent)) {
+                    slots.name = parent.name.getText(ast);
+                }
+            }
+            else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
+                emits.define = parseDefineFunction(node);
+                if (ts.isVariableDeclaration(parent)) {
+                    emits.name = parent.name.getText(ast);
+                }
+            }
+            else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
+                expose.define = parseDefineFunction(node);
+            }
+            else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
+                let statementRange;
+                for (let i = parents.length - 1; i >= 0; i--) {
+                    if (ts.isStatement(parents[i])) {
+                        const statement = parents[i];
+                        statement.forEachChild(child => {
+                            const range = _getStartEnd(child);
+                            statementRange ??= range;
+                            statementRange.end = range.end;
+                        });
+                        break;
+                    }
+                }
+                if (!statementRange) {
+                    statementRange = _getStartEnd(node);
+                }
+                props.define = {
+                    ...parseDefineFunction(node),
+                    statement: statementRange,
+                };
+                if (ts.isVariableDeclaration(parent)) {
+                    props.name = parent.name.getText(ast);
+                }
+                if (node.arguments.length) {
+                    props.define.arg = _getStartEnd(node.arguments[0]);
+                }
+                if (node.typeArguments?.length) {
+                    props.define.typeArg = _getStartEnd(node.typeArguments[0]);
+                }
+            }
+            else if (vueCompilerOptions.macros.withDefaults.includes(callText)) {
+                props.withDefaults = _getStartEnd(node);
+                if (node.arguments.length >= 2) {
+                    const arg = node.arguments[1];
+                    props.withDefaults.arg = _getStartEnd(arg);
+                }
+                if (ts.isVariableDeclaration(parent)) {
+                    props.name = parent.name.getText(ast);
+                }
+            }
+        }
+        node.forEachChild(child => {
+            parents.push(node);
+            visitNode(child, parents);
+            parents.pop();
+        });
+    }
+}
+exports.parseScriptSetupRanges = parseScriptSetupRanges;
+function parseBindingRanges(ts, sourceFile) {
+    const bindings = [];
+    sourceFile.forEachChild(node => {
+        if (ts.isVariableStatement(node)) {
+            for (const node_2 of node.declarationList.declarations) {
+                const vars = _findBindingVars(node_2.name);
+                for (const _var of vars) {
+                    bindings.push(_var);
+                }
+            }
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                bindings.push(_getStartEnd(node.name));
+            }
+        }
+        else if (ts.isClassDeclaration(node)) {
+            if (node.name) {
+                bindings.push(_getStartEnd(node.name));
+            }
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            bindings.push(_getStartEnd(node.name));
+        }
+        if (ts.isImportDeclaration(node)) {
+            if (node.importClause && !node.importClause.isTypeOnly) {
+                if (node.importClause.name) {
+                    bindings.push(_getStartEnd(node.importClause.name));
+                }
+                if (node.importClause.namedBindings) {
+                    if (ts.isNamedImports(node.importClause.namedBindings)) {
+                        for (const element of node.importClause.namedBindings.elements) {
+                            bindings.push(_getStartEnd(element.name));
+                        }
+                    }
+                    else if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+                        bindings.push(_getStartEnd(node.importClause.namedBindings.name));
+                    }
+                }
+            }
+        }
+    });
+    return bindings;
+    function _getStartEnd(node) {
+        return getStartEnd(node, sourceFile);
+    }
+    function _findBindingVars(left) {
+        return findBindingVars(ts, left, sourceFile);
+    }
+}
+exports.parseBindingRanges = parseBindingRanges;
+function findBindingVars(ts, left, sourceFile) {
+    const vars = [];
+    worker(left);
+    return vars;
+    function worker(_node) {
+        if (ts.isIdentifier(_node)) {
+            vars.push(getStartEnd(_node, sourceFile));
+        }
+        // { ? } = ...
+        // [ ? ] = ...
+        else if (ts.isObjectBindingPattern(_node) || ts.isArrayBindingPattern(_node)) {
+            for (const property of _node.elements) {
+                if (ts.isBindingElement(property)) {
+                    worker(property.name);
+                }
+            }
+        }
+        // { foo: ? } = ...
+        else if (ts.isPropertyAssignment(_node)) {
+            worker(_node.initializer);
+        }
+        // { foo } = ...
+        else if (ts.isShorthandPropertyAssignment(_node)) {
+            vars.push(getStartEnd(_node.name, sourceFile));
+        }
+        // { ...? } = ...
+        // [ ...? ] = ...
+        else if (ts.isSpreadAssignment(_node) || ts.isSpreadElement(_node)) {
+            worker(_node.expression);
+        }
+    }
+}
+exports.findBindingVars = findBindingVars;
+function getStartEnd(node, sourceFile) {
+    return {
+        start: node.getStart(sourceFile),
+        end: node.getEnd(),
+    };
+}
+exports.getStartEnd = getStartEnd;
+//# sourceMappingURL=scriptSetupRanges.js.map

node_modules/@vue/language-core/out/plugins.d.ts

@@ -0,0 +1,25 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { VueCompilerOptions } from './types';
+import * as CompilerDOM from '@vue/compiler-dom';
+export declare function getDefaultVueLanguagePlugins(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack: boolean): {
+    version: 1;
+    name?: string | undefined;
+    order?: number | undefined;
+    requiredCompilerOptions?: string[] | undefined;
+    parseSFC?(fileName: string, content: string): import("@vue/compiler-sfc").SFCParseResult | undefined;
+    updateSFC?(oldResult: import("@vue/compiler-sfc").SFCParseResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): import("@vue/compiler-sfc").SFCParseResult | undefined;
+    resolveTemplateCompilerOptions?(options: CompilerDOM.CompilerOptions): CompilerDOM.CompilerOptions;
+    compileSFCTemplate?(lang: string, template: string, options: CompilerDOM.CompilerOptions): CompilerDOM.CodegenResult | undefined;
+    updateSFCTemplate?(oldResult: CompilerDOM.CodegenResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): CompilerDOM.CodegenResult | undefined;
+    getEmbeddedFileNames?(fileName: string, sfc: import("./types").Sfc): string[];
+    resolveEmbeddedFile?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./virtualFile/embeddedFile").VueEmbeddedFile): void;
+}[];
+//# sourceMappingURL=plugins.d.ts.map

node_modules/@vue/language-core/out/plugins.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultVueLanguagePlugins = void 0;
+const file_html_1 = require("./plugins/file-html");
+const file_md_1 = require("./plugins/file-md");
+const file_vue_1 = require("./plugins/file-vue");
+const vue_sfc_customblocks_1 = require("./plugins/vue-sfc-customblocks");
+const vue_sfc_scripts_1 = require("./plugins/vue-sfc-scripts");
+const vue_sfc_styles_1 = require("./plugins/vue-sfc-styles");
+const vue_sfc_template_1 = require("./plugins/vue-sfc-template");
+const vue_template_html_1 = require("./plugins/vue-template-html");
+const vue_tsx_1 = require("./plugins/vue-tsx");
+const CompilerDOM = require("@vue/compiler-dom");
+const CompilerVue2 = require("./utils/vue2TemplateCompiler");
+function getDefaultVueLanguagePlugins(ts, compilerOptions, vueCompilerOptions, codegenStack) {
+    const plugins = [
+        file_md_1.default, // .md for VitePress
+        file_html_1.default, // .html for PetiteVue
+        file_vue_1.default, // .vue and others for Vue
+        vue_template_html_1.default,
+        vue_sfc_styles_1.default,
+        vue_sfc_customblocks_1.default,
+        vue_sfc_scripts_1.default,
+        vue_sfc_template_1.default,
+        vue_tsx_1.default,
+        ...vueCompilerOptions.plugins,
+    ];
+    const pluginCtx = {
+        modules: {
+            '@vue/compiler-dom': vueCompilerOptions.target < 3
+                ? {
+                    ...CompilerDOM,
+                    compile: CompilerVue2.compile,
+                }
+                : CompilerDOM,
+            typescript: ts,
+        },
+        compilerOptions,
+        vueCompilerOptions,
+        codegenStack,
+    };
+    const pluginInstances = plugins
+        .map(plugin => plugin(pluginCtx))
+        .sort((a, b) => {
+        const aOrder = a.order ?? 0;
+        const bOrder = b.order ?? 0;
+        return aOrder - bOrder;
+    });
+    return pluginInstances.filter((plugin) => {
+        const valid = plugin.version >= 1 && plugin.version < 2;
+        if (!valid) {
+            console.warn(`Plugin ${JSON.stringify(plugin.name)} API version incompatible, expected 1.x but got ${JSON.stringify(plugin.version)}`);
+        }
+        return valid;
+    });
+}
+exports.getDefaultVueLanguagePlugins = getDefaultVueLanguagePlugins;
+//# sourceMappingURL=plugins.js.map

node_modules/@vue/language-core/out/plugins/file-html.d.ts

@@ -0,0 +1,4 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+//# sourceMappingURL=file-html.d.ts.map

node_modules/@vue/language-core/out/plugins/file-html.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sfcBlockReg = /\<(script|style)\b([\s\S]*?)\>([\s\S]*?)\<\/\1\>/g;
+const langReg = /\blang\s*=\s*(['\"]?)(\S*)\b\1/;
+const plugin = () => {
+    return {
+        version: 1,
+        parseSFC(fileName, content) {
+            if (fileName.endsWith('.html')) {
+                let sfc = {
+                    descriptor: {
+                        filename: fileName,
+                        source: content,
+                        template: null,
+                        script: null,
+                        scriptSetup: null,
+                        styles: [],
+                        customBlocks: [],
+                        cssVars: [],
+                        shouldForceReload: () => false,
+                        slotted: false,
+                    },
+                    errors: [],
+                };
+                let templateContent = content;
+                for (const match of content.matchAll(sfcBlockReg)) {
+                    const matchText = match[0];
+                    const tag = match[1];
+                    const attrs = match[2];
+                    const lang = attrs.match(langReg)?.[2];
+                    const content = match[3];
+                    const contentStart = match.index + matchText.indexOf(content);
+                    if (tag === 'style') {
+                        sfc.descriptor.styles.push({
+                            attrs: {},
+                            content,
+                            loc: {
+                                start: { column: -1, line: -1, offset: contentStart },
+                                end: { column: -1, line: -1, offset: contentStart + content.length },
+                                source: content,
+                            },
+                            type: 'style',
+                            lang,
+                        });
+                    }
+                    // ignore `<script src="...">`
+                    else if (tag === 'script' && attrs.indexOf('src=') === -1) {
+                        let type = attrs.indexOf('type=') >= 0 ? 'scriptSetup' : 'script';
+                        sfc.descriptor[type] = {
+                            attrs: {},
+                            content,
+                            loc: {
+                                start: { column: -1, line: -1, offset: contentStart },
+                                end: { column: -1, line: -1, offset: contentStart + content.length },
+                                source: content,
+                            },
+                            type: 'script',
+                            lang,
+                        };
+                    }
+                    templateContent = templateContent.substring(0, match.index) + ' '.repeat(matchText.length) + templateContent.substring(match.index + matchText.length);
+                }
+                sfc.descriptor.template = {
+                    attrs: {},
+                    content: templateContent,
+                    loc: {
+                        start: { column: -1, line: -1, offset: 0 },
+                        end: { column: -1, line: -1, offset: templateContent.length },
+                        source: templateContent,
+                    },
+                    type: 'template',
+                    ast: {},
+                };
+                return sfc;
+            }
+            ;
+        }
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=file-html.js.map

node_modules/@vue/language-core/out/plugins/file-md.d.ts

@@ -0,0 +1,4 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+//# sourceMappingURL=file-md.d.ts.map

node_modules/@vue/language-core/out/plugins/file-md.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const source_map_1 = require("@volar/source-map");
+const parseSfc_1 = require("../utils/parseSfc");
+const codeblockReg = /```[\s\S]+?```/g;
+const inlineCodeblockReg = /`[^\n`]+?`/g;
+const scriptSetupReg = /\\\<[\s\S]+?\>\n?/g;
+const sfcBlockReg = /\<(script|style)\b[\s\S]*?\>([\s\S]*?)\<\/\1\>/g;
+const angleBracketReg = /\<\S*\:\S*\>/g;
+const linkReg = /\[[\s\S]*?\]\([\s\S]*?\)/g;
+const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
+const plugin = () => {
+    return {
+        version: 1,
+        parseSFC(fileName, content) {
+            if (fileName.endsWith('.md')) {
+                content = content
+                    // code block
+                    .replace(codeblockReg, match => '```' + ' '.repeat(match.length - 6) + '```')
+                    // inline code block
+                    .replace(inlineCodeblockReg, match => `\`${' '.repeat(match.length - 2)}\``)
+                    // # \<script setup>
+                    .replace(scriptSetupReg, match => ' '.repeat(match.length))
+                    // <<< https://vitepress.dev/guide/markdown#import-code-snippets
+                    .replace(codeSnippetImportReg, match => ' '.repeat(match.length));
+                const codes = [];
+                for (const match of content.matchAll(sfcBlockReg)) {
+                    if (match.index !== undefined) {
+                        const matchText = match[0];
+                        codes.push([matchText, undefined, match.index]);
+                        codes.push('\n\n');
+                        content = content.substring(0, match.index) + ' '.repeat(matchText.length) + content.substring(match.index + matchText.length);
+                    }
+                }
+                content = content
+                    // angle bracket: <http://foo.com>
+                    .replace(angleBracketReg, match => ' '.repeat(match.length))
+                    // [foo](http://foo.com)
+                    .replace(linkReg, match => ' '.repeat(match.length));
+                codes.push('<template>\n');
+                codes.push([content, undefined, 0]);
+                codes.push('\n</template>');
+                const file2VueSourceMap = new source_map_1.SourceMap((0, source_map_1.buildMappings)(codes));
+                const sfc = (0, parseSfc_1.parse)((0, source_map_1.toString)(codes));
+                if (sfc.descriptor.template) {
+                    transformRange(sfc.descriptor.template);
+                }
+                if (sfc.descriptor.script) {
+                    transformRange(sfc.descriptor.script);
+                }
+                if (sfc.descriptor.scriptSetup) {
+                    transformRange(sfc.descriptor.scriptSetup);
+                }
+                for (const style of sfc.descriptor.styles) {
+                    transformRange(style);
+                }
+                for (const customBlock of sfc.descriptor.customBlocks) {
+                    transformRange(customBlock);
+                }
+                return sfc;
+                function transformRange(block) {
+                    block.loc.start.offset = file2VueSourceMap.toSourceOffset(block.loc.start.offset)?.[0] ?? -1;
+                    block.loc.end.offset = file2VueSourceMap.toSourceOffset(block.loc.end.offset)?.[0] ?? -1;
+                }
+            }
+            ;
+        }
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=file-md.js.map

node_modules/@vue/language-core/out/plugins/file-vue.d.ts

@@ -0,0 +1,4 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+//# sourceMappingURL=file-vue.d.ts.map

node_modules/@vue/language-core/out/plugins/file-vue.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSfc_1 = require("../utils/parseSfc");
+const plugin = (_ctx) => {
+    return {
+        version: 1,
+        parseSFC(_fileName, content) {
+            return (0, parseSfc_1.parse)(content);
+        },
+        updateSFC(sfc, change) {
+            const blocks = [
+                sfc.descriptor.template,
+                sfc.descriptor.script,
+                sfc.descriptor.scriptSetup,
+                ...sfc.descriptor.styles,
+                ...sfc.descriptor.customBlocks,
+            ].filter((block) => !!block);
+            const hitBlock = blocks.find(block => change.start >= block.loc.start.offset && change.end <= block.loc.end.offset);
+            if (!hitBlock) {
+                return;
+            }
+            const oldContent = hitBlock.content;
+            const newContent = hitBlock.content =
+                hitBlock.content.substring(0, change.start - hitBlock.loc.start.offset)
+                    + change.newText
+                    + hitBlock.content.substring(change.end - hitBlock.loc.start.offset);
+            // #3449
+            const endTagRegex = new RegExp(`</\\s*${hitBlock.type}\\s*>`);
+            const insertedEndTag = !!oldContent.match(endTagRegex) !== !!newContent.match(endTagRegex);
+            if (insertedEndTag) {
+                return;
+            }
+            const lengthDiff = change.newText.length - (change.end - change.start);
+            for (const block of blocks) {
+                if (block.loc.start.offset > change.end) {
+                    block.loc.start.offset += lengthDiff;
+                }
+                if (block.loc.end.offset >= change.end) {
+                    block.loc.end.offset += lengthDiff;
+                }
+            }
+            return sfc;
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=file-vue.js.map

node_modules/@vue/language-core/out/plugins/vue-sfc-customblocks.d.ts

@@ -0,0 +1,4 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+//# sourceMappingURL=vue-sfc-customblocks.d.ts.map

node_modules/@vue/language-core/out/plugins/vue-sfc-customblocks.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const language_core_1 = require("@volar/language-core");
+const customBlockReg = /^(.*)\.customBlock_([^_]+)_(\d+)\.([^.]+)$/;
+const plugin = () => {
+    return {
+        version: 1,
+        getEmbeddedFileNames(fileName, sfc) {
+            const names = [];
+            for (let i = 0; i < sfc.customBlocks.length; i++) {
+                const customBlock = sfc.customBlocks[i];
+                names.push(fileName + '.customBlock_' + customBlock.type + '_' + i + '.' + customBlock.lang);
+            }
+            return names;
+        },
+        resolveEmbeddedFile(_fileName, sfc, embeddedFile) {
+            const match = embeddedFile.fileName.match(customBlockReg);
+            if (match) {
+                const index = parseInt(match[3]);
+                const customBlock = sfc.customBlocks[index];
+                embeddedFile.capabilities = language_core_1.FileCapabilities.full;
+                embeddedFile.content.push([
+                    customBlock.content,
+                    customBlock.name,
+                    0,
+                    language_core_1.FileRangeCapabilities.full,
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-customblocks.js.map

node_modules/@vue/language-core/out/plugins/vue-sfc-scripts.d.ts

@@ -0,0 +1,4 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+//# sourceMappingURL=vue-sfc-scripts.d.ts.map

node_modules/@vue/language-core/out/plugins/vue-sfc-scripts.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const language_core_1 = require("@volar/language-core");
+const scriptFormatReg = /^(.*)\.script_format\.([^.]+)$/;
+const scriptSetupFormatReg = /^(.*)\.scriptSetup_format\.([^.]+)$/;
+const plugin = () => {
+    return {
+        version: 1,
+        getEmbeddedFileNames(fileName, sfc) {
+            const names = [];
+            if (sfc.script) {
+                names.push(fileName + '.script_format.' + sfc.script.lang);
+            }
+            if (sfc.scriptSetup) {
+                names.push(fileName + '.scriptSetup_format.' + sfc.scriptSetup.lang);
+            }
+            return names;
+        },
+        resolveEmbeddedFile(_fileName, sfc, embeddedFile) {
+            const scriptMatch = embeddedFile.fileName.match(scriptFormatReg);
+            const scriptSetupMatch = embeddedFile.fileName.match(scriptSetupFormatReg);
+            const script = scriptMatch ? sfc.script : scriptSetupMatch ? sfc.scriptSetup : undefined;
+            if (script) {
+                embeddedFile.kind = language_core_1.FileKind.TextFile;
+                embeddedFile.capabilities = {
+                    ...language_core_1.FileCapabilities.full,
+                    diagnostic: false,
+                    codeAction: false,
+                    inlayHint: false,
+                };
+                embeddedFile.content.push([
+                    script.content,
+                    script.name,
+                    0,
+                    {},
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-scripts.js.map

node_modules/@vue/language-core/out/plugins/vue-sfc-styles.d.ts

@@ -0,0 +1,4 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+//# sourceMappingURL=vue-sfc-styles.d.ts.map

node_modules/@vue/language-core/out/plugins/vue-sfc-styles.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const language_core_1 = require("@volar/language-core");
+const styleReg = /^(.*)\.style_(\d+)\.([^.]+)$/;
+const plugin = () => {
+    return {
+        version: 1,
+        getEmbeddedFileNames(fileName, sfc) {
+            const names = [];
+            for (let i = 0; i < sfc.styles.length; i++) {
+                const style = sfc.styles[i];
+                names.push(fileName + '.style_' + i + '.' + style.lang);
+            }
+            return names;
+        },
+        resolveEmbeddedFile(_fileName, sfc, embeddedFile) {
+            const match = embeddedFile.fileName.match(styleReg);
+            if (match) {
+                const index = parseInt(match[2]);
+                const style = sfc.styles[index];
+                embeddedFile.capabilities = language_core_1.FileCapabilities.full;
+                embeddedFile.content.push([
+                    style.content,
+                    style.name,
+                    0,
+                    language_core_1.FileRangeCapabilities.full,
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-styles.js.map

node_modules/@vue/language-core/out/plugins/vue-sfc-template.d.ts

@@ -0,0 +1,4 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+//# sourceMappingURL=vue-sfc-template.d.ts.map

node_modules/@vue/language-core/out/plugins/vue-sfc-template.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const language_core_1 = require("@volar/language-core");
+const templateReg = /^(.*)\.template\.([^.]+)$/;
+const plugin = () => {
+    return {
+        version: 1,
+        getEmbeddedFileNames(fileName, sfc) {
+            if (sfc.template) {
+                return [fileName + '.template.' + sfc.template.lang];
+            }
+            return [];
+        },
+        resolveEmbeddedFile(_fileName, sfc, embeddedFile) {
+            const match = embeddedFile.fileName.match(templateReg);
+            if (match && sfc.template) {
+                embeddedFile.capabilities = language_core_1.FileCapabilities.full;
+                embeddedFile.content.push([
+                    sfc.template.content,
+                    sfc.template.name,
+                    0,
+                    language_core_1.FileRangeCapabilities.full,
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-sfc-template.js.map

node_modules/@vue/language-core/out/plugins/vue-template-html.d.ts

@@ -0,0 +1,4 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+//# sourceMappingURL=vue-template-html.d.ts.map

node_modules/@vue/language-core/out/plugins/vue-template-html.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin = ({ modules }) => {
+    return {
+        version: 1,
+        compileSFCTemplate(lang, template, options) {
+            if (lang === 'html') {
+                const compiler = modules['@vue/compiler-dom'];
+                return compiler.compile(template, {
+                    ...options,
+                    comments: true,
+                });
+            }
+        },
+        updateSFCTemplate(oldResult, change) {
+            const CompilerDOM = modules['@vue/compiler-dom'];
+            const lengthDiff = change.newText.length - (change.end - change.start);
+            let hitNodes = [];
+            if (tryUpdateNode(oldResult.ast) && hitNodes.length) {
+                hitNodes = hitNodes.sort((a, b) => a.loc.source.length - b.loc.source.length);
+                const hitNode = hitNodes[0];
+                if (hitNode.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */) {
+                    return oldResult;
+                }
+            }
+            function tryUpdateNode(node) {
+                if (withinChangeRange(node.loc)) {
+                    hitNodes.push(node);
+                }
+                if (tryUpdateNodeLoc(node.loc)) {
+                    if (node.type === 0 /* CompilerDOM.NodeTypes.ROOT */) {
+                        for (const child of node.children) {
+                            if (!tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                    }
+                    else if (node.type === 1 /* CompilerDOM.NodeTypes.ELEMENT */) {
+                        if (withinChangeRange(node.loc)) {
+                            // if not self closing, should not hit tag name
+                            const start = node.loc.start.offset + 2;
+                            const end = node.loc.start.offset + node.loc.source.lastIndexOf('</');
+                            if (!withinChangeRange({ start: { offset: start }, end: { offset: end }, source: '' })) {
+                                return false;
+                            }
+                        }
+                        for (const prop of node.props) {
+                            if (!tryUpdateNode(prop)) {
+                                return false;
+                            }
+                        }
+                        for (const child of node.children) {
+                            if (!tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                    }
+                    else if (node.type === 6 /* CompilerDOM.NodeTypes.ATTRIBUTE */) {
+                        if (node.value && !tryUpdateNode(node.value)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === 7 /* CompilerDOM.NodeTypes.DIRECTIVE */) {
+                        if (node.arg && withinChangeRange(node.arg.loc) && node.name === 'slot') {
+                            return false;
+                        }
+                        if (node.exp && withinChangeRange(node.exp.loc) && node.name === 'for') { // #2266
+                            return false;
+                        }
+                        if (node.arg && !tryUpdateNode(node.arg)) {
+                            return false;
+                        }
+                        if (node.exp && !tryUpdateNode(node.exp)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === 12 /* CompilerDOM.NodeTypes.TEXT_CALL */) {
+                        if (!tryUpdateNode(node.content)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === 8 /* CompilerDOM.NodeTypes.COMPOUND_EXPRESSION */) {
+                        for (const childNode of node.children) {
+                            if (typeof childNode === 'object') {
+                                if (!tryUpdateNode(childNode)) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                    else if (node.type === 9 /* CompilerDOM.NodeTypes.IF */) {
+                        for (const branch of node.branches) {
+                            if (branch.condition && !tryUpdateNode(branch.condition)) {
+                                return false;
+                            }
+                            for (const child of branch.children) {
+                                if (!tryUpdateNode(child)) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                    else if (node.type === 11 /* CompilerDOM.NodeTypes.FOR */) {
+                        for (const child of [
+                            node.parseResult.source,
+                            node.parseResult.value,
+                            node.parseResult.key,
+                            node.parseResult.index,
+                        ]) {
+                            if (child && !tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                        for (const child of node.children) {
+                            if (!tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                    }
+                    else if (node.type === 5 /* CompilerDOM.NodeTypes.INTERPOLATION */) {
+                        if (!tryUpdateNode(node.content)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */) {
+                        if (withinChangeRange(node.loc)) { // TODO: review this (slot name?)
+                            if (node.isStatic) {
+                                return false;
+                            }
+                            else {
+                                node.content = node.loc.source;
+                            }
+                        }
+                    }
+                    return true;
+                }
+                return false;
+            }
+            function tryUpdateNodeLoc(loc) {
+                delete loc.__endOffset;
+                if (withinChangeRange(loc)) {
+                    loc.source =
+                        loc.source.substring(0, change.start - loc.start.offset)
+                            + change.newText
+                            + loc.source.substring(change.end - loc.start.offset);
+                    loc.__endOffset = loc.end.offset;
+                    loc.end.offset += lengthDiff;
+                    return true;
+                }
+                else if (change.end <= loc.start.offset) {
+                    loc.__endOffset = loc.end.offset;
+                    loc.start.offset += lengthDiff;
+                    loc.end.offset += lengthDiff;
+                    return true;
+                }
+                else if (change.start >= loc.end.offset) {
+                    return true; // no need update
+                }
+                return false;
+            }
+            function withinChangeRange(loc) {
+                const originalLocEnd = loc.__endOffset ?? loc.end.offset;
+                return change.start >= loc.start.offset && change.end <= originalLocEnd;
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-template-html.js.map

node_modules/@vue/language-core/out/plugins/vue-tsx.d.ts

@@ -0,0 +1,80 @@
+import { Sfc, VueLanguagePlugin } from '../types';
+import * as muggle from 'muggle-string';
+export declare const tsCodegen: WeakMap<Sfc, {
+    scriptRanges: () => {
+        exportDefault: (import("../types").TextRange & {
+            expression: import("../types").TextRange;
+            args: import("../types").TextRange;
+            argsNode: import("typescript").ObjectLiteralExpression | undefined;
+            componentsOption: import("../types").TextRange | undefined;
+            componentsOptionNode: import("typescript").ObjectLiteralExpression | undefined;
+            nameOption: import("../types").TextRange | undefined;
+        }) | undefined;
+        bindings: import("../types").TextRange[];
+    } | undefined;
+    scriptSetupRanges: () => {
+        leadingCommentEndOffset: number;
+        importSectionEndOffset: number;
+        bindings: import("../types").TextRange[];
+        props: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            } & {
+                statement: import("../types").TextRange;
+            }) | undefined;
+            withDefaults?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
+        slots: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
+        emits: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
+        expose: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
+        defineProp: {
+            name: import("../types").TextRange | undefined;
+            nameIsString: boolean;
+            type: import("../types").TextRange | undefined;
+            defaultValue: import("../types").TextRange | undefined;
+            required: boolean;
+        }[];
+    } | undefined;
+    lang: () => string;
+    generatedScript: () => {
+        codes: muggle.Segment<import("@volar/language-core").FileRangeCapabilities>[];
+        codeStacks: muggle.StackNode[];
+        mirrorBehaviorMappings: import("@volar/source-map").Mapping<[import("@volar/language-core").MirrorBehaviorCapabilities, import("@volar/language-core").MirrorBehaviorCapabilities]>[];
+    };
+    generatedTemplate: () => {
+        codes: (string | [string, string | undefined, number | [number, number], import("@volar/language-core").FileRangeCapabilities])[];
+        codeStacks: muggle.StackNode[];
+        formatCodes: (string | [string, string | undefined, number | [number, number], import("@volar/language-core").FileRangeCapabilities])[];
+        formatCodeStacks: muggle.StackNode[];
+        cssCodes: (string | [string, string | undefined, number | [number, number], import("@volar/language-core").FileRangeCapabilities])[];
+        cssCodeStacks: muggle.StackNode[];
+        tagNames: Record<string, number[]>;
+        accessedGlobalVariables: Set<string>;
+        hasSlot: boolean;
+    } | undefined;
+}>;
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+//# sourceMappingURL=vue-tsx.d.ts.map

node_modules/@vue/language-core/out/plugins/vue-tsx.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsCodegen = void 0;
+const computeds_1 = require("computeds");
+const script_1 = require("../generators/script");
+const template_1 = require("../generators/template");
+const scriptRanges_1 = require("../parsers/scriptRanges");
+const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
+const language_core_1 = require("@volar/language-core");
+const muggle = require("muggle-string");
+const templateFormatReg = /^\.template_format\.ts$/;
+const templateStyleCssReg = /^\.template_style\.css$/;
+exports.tsCodegen = new WeakMap();
+const plugin = (ctx) => {
+    return {
+        version: 1,
+        requiredCompilerOptions: [
+            'noPropertyAccessFromIndexSignature',
+            'exactOptionalPropertyTypes',
+        ],
+        getEmbeddedFileNames(fileName, sfc) {
+            const tsx = useTsx(fileName, sfc);
+            const fileNames = [];
+            if (['js', 'ts', 'jsx', 'tsx'].includes(tsx.lang())) {
+                fileNames.push(fileName + '.' + tsx.lang());
+            }
+            if (sfc.template) {
+                fileNames.push(fileName + '.template_format.ts');
+                fileNames.push(fileName + '.template_style.css');
+            }
+            return fileNames;
+        },
+        resolveEmbeddedFile(fileName, sfc, embeddedFile) {
+            const _tsx = useTsx(fileName, sfc);
+            const suffix = embeddedFile.fileName.replace(fileName, '');
+            if (suffix === '.' + _tsx.lang()) {
+                embeddedFile.kind = language_core_1.FileKind.TypeScriptHostFile;
+                embeddedFile.capabilities = {
+                    ...language_core_1.FileCapabilities.full,
+                    foldingRange: false,
+                    documentFormatting: false,
+                    documentSymbol: false,
+                };
+                const tsx = _tsx.generatedScript();
+                if (tsx) {
+                    const [content, contentStacks] = ctx.codegenStack ? muggle.track([...tsx.codes], [...tsx.codeStacks]) : [[...tsx.codes], [...tsx.codeStacks]];
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
+                    embeddedFile.mirrorBehaviorMappings = [...tsx.mirrorBehaviorMappings];
+                }
+            }
+            else if (suffix.match(templateFormatReg)) {
+                embeddedFile.parentFileName = fileName + '.template.' + sfc.template?.lang;
+                embeddedFile.kind = language_core_1.FileKind.TextFile;
+                embeddedFile.capabilities = {
+                    ...language_core_1.FileCapabilities.full,
+                    diagnostic: false,
+                    foldingRange: false,
+                    codeAction: false,
+                    inlayHint: false,
+                };
+                const template = _tsx.generatedTemplate();
+                if (template) {
+                    const [content, contentStacks] = ctx.codegenStack
+                        ? muggle.track([...template.formatCodes], [...template.formatCodeStacks])
+                        : [[...template.formatCodes], [...template.formatCodeStacks]];
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
+                }
+                for (const style of sfc.styles) {
+                    embeddedFile.content.push('\n\n');
+                    for (const cssVar of style.cssVars) {
+                        embeddedFile.content.push('(');
+                        embeddedFile.content.push([
+                            cssVar.text,
+                            style.name,
+                            cssVar.offset,
+                            {},
+                        ]);
+                        embeddedFile.content.push(');\n');
+                    }
+                }
+            }
+            else if (suffix.match(templateStyleCssReg)) {
+                embeddedFile.parentFileName = fileName + '.template.' + sfc.template?.lang;
+                const template = _tsx.generatedTemplate();
+                if (template) {
+                    const [content, contentStacks] = ctx.codegenStack
+                        ? muggle.track([...template.cssCodes], [...template.cssCodeStacks])
+                        : [[...template.cssCodes], [...template.cssCodeStacks]];
+                    embeddedFile.content = content;
+                    embeddedFile.contentStacks = contentStacks;
+                }
+                // for color pickers support
+                embeddedFile.capabilities.documentSymbol = true;
+            }
+        },
+    };
+    function useTsx(fileName, sfc) {
+        if (!exports.tsCodegen.has(sfc)) {
+            exports.tsCodegen.set(sfc, createTsx(fileName, sfc, ctx));
+        }
+        return exports.tsCodegen.get(sfc);
+    }
+};
+exports.default = plugin;
+function createTsx(fileName, _sfc, { vueCompilerOptions, compilerOptions, codegenStack, modules }) {
+    const ts = modules.typescript;
+    const lang = (0, computeds_1.computed)(() => {
+        return !_sfc.script && !_sfc.scriptSetup ? 'ts'
+            : _sfc.scriptSetup && _sfc.scriptSetup.lang !== 'js' ? _sfc.scriptSetup.lang
+                : _sfc.script && _sfc.script.lang !== 'js' ? _sfc.script.lang
+                    : 'js';
+    });
+    const scriptRanges = (0, computeds_1.computed)(() => _sfc.script
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.script.ast, !!_sfc.scriptSetup, false)
+        : undefined);
+    const scriptSetupRanges = (0, computeds_1.computed)(() => _sfc.scriptSetup
+        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, vueCompilerOptions)
+        : undefined);
+    const shouldGenerateScopedClasses = (0, computeds_1.computed)(() => {
+        const option = vueCompilerOptions.experimentalResolveStyleCssClasses;
+        return _sfc.styles.some(s => {
+            return option === 'always' || (option === 'scoped' && s.scoped);
+        });
+    });
+    const stylesScopedClasses = (0, computeds_1.computedSet)(() => {
+        const classes = new Set();
+        if (!shouldGenerateScopedClasses()) {
+            return classes;
+        }
+        for (const style of _sfc.styles) {
+            const option = vueCompilerOptions.experimentalResolveStyleCssClasses;
+            if (option === 'always' || (option === 'scoped' && style.scoped)) {
+                for (const className of style.classNames) {
+                    classes.add(className.text.substring(1));
+                }
+            }
+        }
+        return classes;
+    });
+    const generatedTemplate = (0, computeds_1.computed)(() => {
+        if (!_sfc.template)
+            return;
+        return (0, template_1.generate)(ts, compilerOptions, vueCompilerOptions, _sfc.template, shouldGenerateScopedClasses(), stylesScopedClasses(), hasScriptSetupSlots(), slotsAssignName(), propsAssignName(), codegenStack);
+    });
+    const hasScriptSetupSlots = (0, computeds_1.computed)(() => !!scriptSetupRanges()?.slots.define);
+    const slotsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.slots.name);
+    const propsAssignName = (0, computeds_1.computed)(() => scriptSetupRanges()?.props.name);
+    const generatedScript = (0, computeds_1.computed)(() => (0, script_1.generate)(ts, fileName, _sfc.script, _sfc.scriptSetup, _sfc.styles, lang(), scriptRanges(), scriptSetupRanges(), generatedTemplate(), compilerOptions, vueCompilerOptions, codegenStack));
+    return {
+        scriptRanges,
+        scriptSetupRanges,
+        lang,
+        generatedScript,
+        generatedTemplate,
+    };
+}
+//# sourceMappingURL=vue-tsx.js.map

node_modules/@vue/language-core/out/types.d.ts

@@ -0,0 +1,125 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+import type { SFCParseResult } from '@vue/compiler-sfc';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type { VueEmbeddedFile } from './virtualFile/embeddedFile';
+export type { SFCParseResult } from '@vue/compiler-sfc';
+export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
+    target?: 'auto' | 2 | 2.7 | 3 | 3.3;
+    plugins?: string[];
+};
+export interface VueCompilerOptions {
+    target: number;
+    lib: string;
+    extensions: string[];
+    jsxSlots: boolean;
+    strictTemplates: boolean;
+    skipTemplateCodegen: boolean;
+    nativeTags: string[];
+    dataAttributes: string[];
+    htmlAttributes: string[];
+    optionsWrapper: [string, string] | [];
+    macros: {
+        defineProps: string[];
+        defineSlots: string[];
+        defineEmits: string[];
+        defineExpose: string[];
+        defineModel: string[];
+        defineOptions: string[];
+        withDefaults: string[];
+    };
+    plugins: VueLanguagePlugin[];
+    hooks: string[];
+    experimentalDefinePropProposal: 'kevinEdition' | 'johnsonEdition' | false;
+    experimentalResolveStyleCssClasses: 'scoped' | 'always' | 'never';
+    experimentalModelPropName: Record<string, Record<string, boolean | Record<string, string> | Record<string, string>[]>>;
+    experimentalUseElementAccessInTemplate: boolean;
+    experimentalAdditionalLanguageModules: string[];
+}
+export type VueLanguagePlugin = (ctx: {
+    modules: {
+        typescript: typeof import('typescript/lib/tsserverlibrary');
+        '@vue/compiler-dom': typeof import('@vue/compiler-dom');
+    };
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    codegenStack: boolean;
+}) => {
+    version: 1;
+    name?: string;
+    order?: number;
+    requiredCompilerOptions?: string[];
+    parseSFC?(fileName: string, content: string): SFCParseResult | undefined;
+    updateSFC?(oldResult: SFCParseResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): SFCParseResult | undefined;
+    resolveTemplateCompilerOptions?(options: CompilerDOM.CompilerOptions): CompilerDOM.CompilerOptions;
+    compileSFCTemplate?(lang: string, template: string, options: CompilerDOM.CompilerOptions): CompilerDOM.CodegenResult | undefined;
+    updateSFCTemplate?(oldResult: CompilerDOM.CodegenResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): CompilerDOM.CodegenResult | undefined;
+    getEmbeddedFileNames?(fileName: string, sfc: Sfc): string[];
+    resolveEmbeddedFile?(fileName: string, sfc: Sfc, embeddedFile: VueEmbeddedFile): void;
+};
+export interface SfcBlock {
+    name: string;
+    start: number;
+    end: number;
+    startTagEnd: number;
+    endTagStart: number;
+    lang: string;
+    content: string;
+    attrs: Record<string, string | true>;
+}
+export interface Sfc {
+    template: SfcBlock & {
+        ast: CompilerDOM.RootNode | undefined;
+        errors: CompilerDOM.CompilerError[];
+        warnings: CompilerDOM.CompilerError[];
+    } | undefined;
+    script: (SfcBlock & {
+        src: string | undefined;
+        srcOffset: number;
+        ast: ts.SourceFile;
+    }) | undefined;
+    scriptSetup: SfcBlock & {
+        generic: string | undefined;
+        genericOffset: number;
+        ast: ts.SourceFile;
+    } | undefined;
+    styles: readonly (SfcBlock & {
+        module: string | undefined;
+        scoped: boolean;
+        cssVars: {
+            text: string;
+            offset: number;
+        }[];
+        classNames: {
+            text: string;
+            offset: number;
+        }[];
+    })[];
+    customBlocks: readonly (SfcBlock & {
+        type: string;
+    })[];
+    /**
+     * @deprecated use `template.ast` instead
+     */
+    templateAst: CompilerDOM.RootNode | undefined;
+    /**
+     * @deprecated use `script.ast` instead
+     */
+    scriptAst: ts.SourceFile | undefined;
+    /**
+     * @deprecated use `scriptSetup.ast` instead
+     */
+    scriptSetupAst: ts.SourceFile | undefined;
+}
+export interface TextRange {
+    start: number;
+    end: number;
+}
+//# sourceMappingURL=types.d.ts.map

node_modules/@vue/language-core/out/types.js

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

node_modules/@vue/language-core/out/utils/globalTypes.d.ts

@@ -0,0 +1,4 @@
+import { VueCompilerOptions } from '../types';
+export declare const baseName = "__VLS_types.d.ts";
+export declare function getTypesCode(vueCompilerOptions: VueCompilerOptions): string;
+//# sourceMappingURL=globalTypes.d.ts.map

node_modules/@vue/language-core/out/utils/globalTypes.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypesCode = exports.baseName = void 0;
+const shared_1 = require("./shared");
+exports.baseName = '__VLS_types.d.ts';
+function getTypesCode(vueCompilerOptions) {
+    return `
+// @ts-nocheck
+
+type __VLS_IntrinsicElements = __VLS_PickNotAny<import('vue/jsx-runtime').JSX.IntrinsicElements, __VLS_PickNotAny<JSX.IntrinsicElements, Record<string, any>>>;
+type __VLS_Element = __VLS_PickNotAny<import('vue/jsx-runtime').JSX.Element, JSX.Element>;
+
+type __VLS_IsAny<T> = 0 extends 1 & T ? true : false;
+type __VLS_PickNotAny<A, B> = __VLS_IsAny<A> extends true ? B : A;
+
+type __VLS_Prettify<T> = { [K in keyof T]: T[K]; } & {};
+
+type __VLS_OmitKeepDiscriminatedUnion<T, K extends keyof any> =
+	T extends any
+		? Pick<T, Exclude<keyof T, K>>
+		: never;
+
+type __VLS_GlobalComponents =
+	__VLS_PickNotAny<import('vue').GlobalComponents, {}>
+	& __VLS_PickNotAny<import('@vue/runtime-core').GlobalComponents, {}>
+	& __VLS_PickNotAny<import('@vue/runtime-dom').GlobalComponents, {}>
+	& Pick<typeof import('${vueCompilerOptions.lib}'),
+		'Transition'
+		| 'TransitionGroup'
+		| 'KeepAlive'
+		| 'Suspense'
+		| 'Teleport'
+	>;
+
+declare const __VLS_intrinsicElements: __VLS_IntrinsicElements;
+
+// v-for
+declare function __VLS_getVForSourceType(source: number): [number, number, number][];
+declare function __VLS_getVForSourceType(source: string): [string, number, number][];
+declare function __VLS_getVForSourceType<T extends any[]>(source: T): [
+	T[number], // item
+	number, // key
+	number, // index
+][];
+declare function __VLS_getVForSourceType<T extends { [Symbol.iterator](): Iterator<any> }>(source: T): [
+	T extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never, // item 
+	number, // key
+	undefined, // index
+][];
+declare function __VLS_getVForSourceType<T>(source: T): [
+	T[keyof T], // item
+	keyof T, // key
+	number, // index
+][];
+
+declare function __VLS_getSlotParams<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>;
+declare function __VLS_getSlotParam<T>(slot: T): Parameters<__VLS_PickNotAny<NonNullable<T>, (...args: any[]) => any>>[0];
+declare function __VLS_directiveFunction<T>(dir: T):
+	T extends import('${vueCompilerOptions.lib}').ObjectDirective<infer E, infer V> | import('${vueCompilerOptions.lib}').FunctionDirective<infer E, infer V> ? (value: V) => void
+	: T;
+declare function __VLS_withScope<T, K>(ctx: T, scope: K): ctx is T & K;
+declare function __VLS_makeOptional<T>(t: T): { [K in keyof T]?: T[K] };
+
+type __VLS_SelfComponent<N, C> = string extends N ? {} : N extends string ? { [P in N]: C } : {};
+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> : { [K in N0]: LocalComponents[N1] } :
+	N2 extends keyof LocalComponents ? N2 extends N0 ? Pick<LocalComponents, N0> : { [K in N0]: LocalComponents[N2] } :
+	N3 extends keyof LocalComponents ? N3 extends N0 ? Pick<LocalComponents, N0> : { [K in N0]: LocalComponents[N3] } :
+	N1 extends keyof __VLS_GlobalComponents ? N1 extends N0 ? Pick<__VLS_GlobalComponents, N0> : { [K in N0]: __VLS_GlobalComponents[N1] } :
+	N2 extends keyof __VLS_GlobalComponents ? N2 extends N0 ? Pick<__VLS_GlobalComponents, N0> : { [K in N0]: __VLS_GlobalComponents[N2] } :
+	N3 extends keyof __VLS_GlobalComponents ? N3 extends N0 ? Pick<__VLS_GlobalComponents, N0> : { [K in N0]: __VLS_GlobalComponents[N3] } :
+	${vueCompilerOptions.strictTemplates ? '{}' : '{ [K in N0]: unknown }'}
+
+type __VLS_FillingEventArg_ParametersLength<E extends (...args: any) => any> = __VLS_IsAny<Parameters<E>> extends true ? -1 : Parameters<E>['length'];
+type __VLS_FillingEventArg<E> = E extends (...args: any) => any ? __VLS_FillingEventArg_ParametersLength<E> extends 0 ? ($event?: undefined) => ReturnType<E> : E : E;
+declare 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: (K extends { $props: infer Props } ? Props : any)${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: {
+		attrs?: any,
+		slots?: K extends { ${(0, shared_1.getSlotsPropertyName)(vueCompilerOptions.target)}: infer Slots } ? Slots : any,
+		emit?: K extends { $emit: infer Emit } ? Emit : any
+	}) => __VLS_Element & { __ctx?: typeof ctx & { props?: typeof props; expose?(exposed: K): void; } }
+	: T extends () => any ? (props: {}, ctx?: any) => ReturnType<T>
+	: T extends (...args: any) => any ? T
+	: (_: {}${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: {}${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'} } };
+declare function __VLS_elementAsFunctionalComponent<T>(t: T): (_: T${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'}, ctx?: any) => { __ctx?: { attrs?: any, expose?: any, slots?: any, emit?: any, props?: T${vueCompilerOptions.strictTemplates ? '' : ' & Record<string, unknown>'} } };
+declare function __VLS_functionalComponentArgsRest<T extends (...args: any) => any>(t: T): Parameters<T>['length'] extends 2 ? [any] : [];
+declare function __VLS_pickEvent<E1, E2>(emitEvent: E1, propEvent: E2): __VLS_FillingEventArg<
+	__VLS_PickNotAny<
+		__VLS_AsFunctionOrAny<E2>,
+		__VLS_AsFunctionOrAny<E1>
+	>
+> | undefined;
+declare function __VLS_pickFunctionalComponentCtx<T, K>(comp: T, compInstance: K): __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_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_AsFunctionOrAny<F> = unknown extends F ? any : ((...args: any) => any) extends F ? F : any;
+
+declare function __VLS_normalizeSlot<S>(s: S): S extends () => infer R ? (props: {}) => R : S;
+
+/**
+ * emit
+ */
+// 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_Prettify<
+	__VLS_UnionToIntersection<
+		__VLS_ConstructorOverloads<T> & {
+			[K in keyof T]: T[K] extends any[] ? { (...args: T[K]): void } : never
+		}
+	>
+>;
+`.trim();
+}
+exports.getTypesCode = getTypesCode;
+//# sourceMappingURL=globalTypes.js.map

node_modules/@vue/language-core/out/utils/parseCssClassNames.d.ts

@@ -0,0 +1,5 @@
+export declare function parseCssClassNames(styleContent: string): Generator<{
+    offset: number;
+    text: string;
+}, void, unknown>;
+//# sourceMappingURL=parseCssClassNames.d.ts.map

node_modules/@vue/language-core/out/utils/parseCssClassNames.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCssClassNames = void 0;
+const parseCssVars_1 = require("./parseCssVars");
+const cssClassNameReg = /(?=([\.]{1}[a-zA-Z_]+[\w\_\-]*)[\s\.\+\{\>#\:]{1})/g;
+function* parseCssClassNames(styleContent) {
+    styleContent = (0, parseCssVars_1.clearComments)(styleContent);
+    const matches = styleContent.matchAll(cssClassNameReg);
+    for (const match of matches) {
+        if (match.index !== undefined) {
+            const matchText = match[1];
+            if (matchText !== undefined) {
+                yield { offset: match.index, text: matchText };
+            }
+        }
+    }
+}
+exports.parseCssClassNames = parseCssClassNames;
+//# sourceMappingURL=parseCssClassNames.js.map

node_modules/@vue/language-core/out/utils/parseCssVars.d.ts

@@ -0,0 +1,6 @@
+export declare function parseCssVars(styleContent: string): Generator<{
+    offset: number;
+    text: string;
+}, void, unknown>;
+export declare function clearComments(css: string): string;
+//# sourceMappingURL=parseCssVars.d.ts.map

node_modules/@vue/language-core/out/utils/parseCssVars.js

@@ -0,0 +1,28 @@
+"use strict";
+// https://github.com/vuejs/core/blob/main/packages/compiler-sfc/src/cssVars.ts#L47-L61
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearComments = exports.parseCssVars = void 0;
+const vBindCssVarReg = /\bv-bind\(\s*(?:'([^']+)'|"([^"]+)"|([^'"][^)]*))\s*\)/g;
+const commentReg1 = /\/\*([\s\S]*?)\*\//g;
+const commentReg2 = /\/\/([\s\S]*?)\n/g;
+function* parseCssVars(styleContent) {
+    styleContent = clearComments(styleContent);
+    const matchs = styleContent.matchAll(vBindCssVarReg);
+    for (const match of matchs) {
+        if (match.index !== undefined) {
+            const matchText = match[1] ?? match[2] ?? match[3];
+            if (matchText !== undefined) {
+                const offset = match.index + styleContent.slice(match.index).indexOf(matchText);
+                yield { offset, text: matchText };
+            }
+        }
+    }
+}
+exports.parseCssVars = parseCssVars;
+function clearComments(css) {
+    return css
+        .replace(commentReg1, match => `/*${' '.repeat(match.length - 4)}*/`)
+        .replace(commentReg2, match => `//${' '.repeat(match.length - 3)}\n`);
+}
+exports.clearComments = clearComments;
+//# sourceMappingURL=parseCssVars.js.map

node_modules/@vue/language-core/out/utils/parseSfc.d.ts

@@ -0,0 +1,3 @@
+import type { SFCParseResult } from '@vue/compiler-sfc';
+export declare function parse(source: string): SFCParseResult;
+//# sourceMappingURL=parseSfc.d.ts.map

node_modules/@vue/language-core/out/utils/parseSfc.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const compiler = require("@vue/compiler-dom");
+function parse(source) {
+    const errors = [];
+    const ast = compiler.parse(source, {
+        // there are no components at SFC parsing level
+        isNativeTag: () => true,
+        // preserve all whitespaces
+        isPreTag: () => true,
+        getTextMode: ({ tag, props }, parent) => {
+            if ((!parent && tag !== 'template')
+                || (tag === 'template'
+                    && props.some(p => p.type === 6 /* compiler.NodeTypes.ATTRIBUTE */ &&
+                        p.name === 'lang' &&
+                        p.value &&
+                        p.value.content &&
+                        p.value.content !== 'html'))) {
+                return 2 /* compiler.TextModes.RAWTEXT */;
+            }
+            else {
+                return 0 /* compiler.TextModes.DATA */;
+            }
+        },
+        onError: e => {
+            errors.push(e);
+        },
+        comments: true,
+    });
+    const descriptor = {
+        filename: 'anonymous.vue',
+        source,
+        template: null,
+        script: null,
+        scriptSetup: null,
+        styles: [],
+        customBlocks: [],
+        cssVars: [],
+        slotted: false,
+        shouldForceReload: () => false,
+    };
+    ast.children.forEach(node => {
+        if (node.type !== 1 /* compiler.NodeTypes.ELEMENT */) {
+            return;
+        }
+        switch (node.tag) {
+            case 'template':
+                const templateBlock = (descriptor.template = createBlock(node, source));
+                templateBlock.ast = node;
+                break;
+            case 'script':
+                const scriptBlock = createBlock(node, source);
+                const isSetup = !!scriptBlock.attrs.setup;
+                if (isSetup && !descriptor.scriptSetup) {
+                    descriptor.scriptSetup = scriptBlock;
+                    break;
+                }
+                if (!isSetup && !descriptor.script) {
+                    descriptor.script = scriptBlock;
+                    break;
+                }
+                break;
+            case 'style':
+                const styleBlock = createBlock(node, source);
+                descriptor.styles.push(styleBlock);
+                break;
+            default:
+                descriptor.customBlocks.push(createBlock(node, source));
+                break;
+        }
+    });
+    return {
+        descriptor,
+        errors,
+    };
+}
+exports.parse = parse;
+function createBlock(node, source) {
+    const type = node.tag;
+    let { start, end } = node.loc;
+    let content = '';
+    if (node.children.length) {
+        start = node.children[0].loc.start;
+        end = node.children[node.children.length - 1].loc.end;
+        content = source.slice(start.offset, end.offset);
+    }
+    else {
+        const offset = node.loc.source.indexOf(`</`);
+        if (offset > -1) {
+            start = {
+                line: start.line,
+                column: start.column + offset,
+                offset: start.offset + offset
+            };
+        }
+        end = Object.assign({}, start);
+    }
+    const loc = {
+        source: content,
+        start,
+        end
+    };
+    const attrs = {};
+    const block = {
+        type,
+        content,
+        loc,
+        attrs
+    };
+    node.props.forEach(p => {
+        if (p.type === 6 /* compiler.NodeTypes.ATTRIBUTE */) {
+            attrs[p.name] = p.value ? p.value.content || true : true;
+            if (p.name === 'lang') {
+                block.lang = p.value && p.value.content;
+            }
+            else if (p.name === 'src') {
+                block.src = p.value && p.value.content;
+            }
+            else if (type === 'style') {
+                if (p.name === 'scoped') {
+                    block.scoped = true;
+                }
+                else if (p.name === 'module') {
+                    block.module = attrs[p.name];
+                }
+            }
+            else if (type === 'script' && p.name === 'setup') {
+                block.setup = attrs.setup;
+            }
+        }
+    });
+    return block;
+}
+//# sourceMappingURL=parseSfc.js.map

node_modules/@vue/language-core/out/utils/shared.d.ts

@@ -0,0 +1,4 @@
+export declare function getSlotsPropertyName(vueVersion: number): "$scopedSlots" | "$slots";
+export { hyphenate as hyphenateTag } from '@vue/shared';
+export declare function hyphenateAttr(str: string): string;
+//# sourceMappingURL=shared.d.ts.map

node_modules/@vue/language-core/out/utils/shared.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hyphenateAttr = exports.hyphenateTag = exports.getSlotsPropertyName = void 0;
+const shared_1 = require("@vue/shared");
+function getSlotsPropertyName(vueVersion) {
+    return vueVersion < 3 ? '$scopedSlots' : '$slots';
+}
+exports.getSlotsPropertyName = getSlotsPropertyName;
+var shared_2 = require("@vue/shared");
+Object.defineProperty(exports, "hyphenateTag", { enumerable: true, get: function () { return shared_2.hyphenate; } });
+function hyphenateAttr(str) {
+    let hyphencase = (0, shared_1.hyphenate)(str);
+    // fix https://github.com/vuejs/core/issues/8811
+    if (str.length && str[0] !== str[0].toLowerCase()) {
+        hyphencase = '-' + hyphencase;
+    }
+    return hyphencase;
+}
+exports.hyphenateAttr = hyphenateAttr;
+//# sourceMappingURL=shared.js.map

node_modules/@vue/language-core/out/utils/transform.d.ts

@@ -0,0 +1,9 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { VueCompilerOptions } from '../types';
+export declare function walkInterpolationFragment(ts: typeof import('typescript/lib/tsserverlibrary'), code: string, ast: ts.SourceFile, cb: (fragment: string, offset: number | undefined, isJustForErrorMapping?: boolean) => void, localVars: Map<string, number>, identifiers: Set<string>, vueOptions: VueCompilerOptions): {
+    text: string;
+    isShorthand: boolean;
+    offset: number;
+}[];
+export declare function collectVars(ts: typeof import('typescript/lib/tsserverlibrary'), node: ts.Node, result: string[]): void;
+//# sourceMappingURL=transform.d.ts.map

node_modules/@vue/language-core/out/utils/transform.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectVars = exports.walkInterpolationFragment = void 0;
+const shared_1 = require("@vue/shared");
+function walkInterpolationFragment(ts, code, ast, cb, localVars, identifiers, vueOptions) {
+    let ctxVars = [];
+    const varCb = (id, isShorthand) => {
+        if (localVars.get(id.text) ||
+            // https://github.com/vuejs/core/blob/245230e135152900189f13a4281302de45fdcfaa/packages/compiler-core/src/transforms/transformExpression.ts#L342-L352
+            (0, shared_1.isGloballyWhitelisted)(id.text) ||
+            id.text === 'require' ||
+            id.text.startsWith('__VLS_')) {
+            // localVarOffsets.push(localVar.getStart(ast));
+        }
+        else {
+            ctxVars.push({
+                text: id.text,
+                isShorthand: isShorthand,
+                offset: id.getStart(ast),
+            });
+            identifiers.add(id.text);
+        }
+    };
+    ast.forEachChild(node => walkIdentifiers(ts, node, varCb, localVars));
+    ctxVars = ctxVars.sort((a, b) => a.offset - b.offset);
+    if (ctxVars.length) {
+        if (ctxVars[0].isShorthand) {
+            cb(code.substring(0, ctxVars[0].offset + ctxVars[0].text.length), 0);
+            cb(': ', undefined);
+        }
+        else {
+            cb(code.substring(0, ctxVars[0].offset), 0);
+        }
+        for (let i = 0; i < ctxVars.length - 1; i++) {
+            // fix https://github.com/vuejs/language-tools/issues/1205
+            // fix https://github.com/vuejs/language-tools/issues/1264
+            cb('', ctxVars[i + 1].offset, true);
+            if (vueOptions.experimentalUseElementAccessInTemplate) {
+                const varStart = ctxVars[i].offset;
+                const varEnd = ctxVars[i].offset + ctxVars[i].text.length;
+                cb('__VLS_ctx[', undefined);
+                cb('', varStart, true);
+                cb("'", undefined);
+                cb(code.substring(varStart, varEnd), varStart);
+                cb("'", undefined);
+                cb('', varEnd, true);
+                cb(']', undefined);
+                if (ctxVars[i + 1].isShorthand) {
+                    cb(code.substring(varEnd, ctxVars[i + 1].offset + ctxVars[i + 1].text.length), varEnd);
+                    cb(': ', undefined);
+                }
+                else {
+                    cb(code.substring(varEnd, ctxVars[i + 1].offset), varEnd);
+                }
+            }
+            else {
+                cb('__VLS_ctx.', undefined);
+                if (ctxVars[i + 1].isShorthand) {
+                    cb(code.substring(ctxVars[i].offset, ctxVars[i + 1].offset + ctxVars[i + 1].text.length), ctxVars[i].offset);
+                    cb(': ', undefined);
+                }
+                else {
+                    cb(code.substring(ctxVars[i].offset, ctxVars[i + 1].offset), ctxVars[i].offset);
+                }
+            }
+        }
+        if (vueOptions.experimentalUseElementAccessInTemplate) {
+            const varStart = ctxVars[ctxVars.length - 1].offset;
+            const varEnd = ctxVars[ctxVars.length - 1].offset + ctxVars[ctxVars.length - 1].text.length;
+            cb('__VLS_ctx[', undefined);
+            cb('', varStart, true);
+            cb("'", undefined);
+            cb(code.substring(varStart, varEnd), varStart);
+            cb("'", undefined);
+            cb('', varEnd, true);
+            cb(']', undefined);
+            cb(code.substring(varEnd), varEnd);
+        }
+        else {
+            cb('', ctxVars[ctxVars.length - 1].offset, true);
+            cb('__VLS_ctx.', undefined);
+            cb(code.substring(ctxVars[ctxVars.length - 1].offset), ctxVars[ctxVars.length - 1].offset);
+        }
+    }
+    else {
+        cb(code, 0);
+    }
+    return ctxVars;
+}
+exports.walkInterpolationFragment = walkInterpolationFragment;
+function walkIdentifiers(ts, node, cb, localVars, 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, cb, localVars, blockVars, false);
+    }
+    else if (ts.isVariableDeclaration(node)) {
+        collectVars(ts, node.name, blockVars);
+        for (const varName of blockVars) {
+            localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
+        }
+        if (node.initializer)
+            walkIdentifiers(ts, node.initializer, cb, localVars, blockVars, false);
+    }
+    else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        const functionArgs = [];
+        for (const param of node.parameters) {
+            collectVars(ts, param.name, functionArgs);
+            if (param.type) {
+                walkIdentifiers(ts, param.type, cb, localVars, blockVars, false);
+            }
+        }
+        for (const varName of functionArgs)
+            localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
+        walkIdentifiers(ts, node.body, cb, localVars, blockVars, false);
+        for (const varName of functionArgs)
+            localVars.set(varName, localVars.get(varName) - 1);
+    }
+    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, cb, localVars, blockVars, false);
+                }
+                walkIdentifiers(ts, prop.initializer, cb, localVars, blockVars, false);
+            }
+            // fix https://github.com/vuejs/language-tools/issues/1156
+            else if (ts.isShorthandPropertyAssignment(prop)) {
+                walkIdentifiers(ts, prop, cb, localVars, 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, cb, localVars, blockVars, false);
+            }
+        }
+    }
+    else if (ts.isTypeReferenceNode(node)) {
+        // fix https://github.com/vuejs/language-tools/issues/1422
+        node.forEachChild(node => walkIdentifiersInTypeReference(ts, node, cb));
+    }
+    else {
+        const _blockVars = blockVars;
+        if (ts.isBlock(node)) {
+            blockVars = [];
+        }
+        node.forEachChild(node => walkIdentifiers(ts, node, cb, localVars, blockVars, false));
+        if (ts.isBlock(node)) {
+            for (const varName of blockVars) {
+                localVars.set(varName, localVars.get(varName) - 1);
+            }
+        }
+        blockVars = _blockVars;
+    }
+    if (isRoot) {
+        for (const varName of blockVars) {
+            localVars.set(varName, localVars.get(varName) - 1);
+        }
+    }
+}
+function walkIdentifiersInTypeReference(ts, node, cb) {
+    if (ts.isTypeQueryNode(node) && ts.isIdentifier(node.exprName)) {
+        cb(node.exprName, false);
+    }
+    else {
+        node.forEachChild(node => walkIdentifiersInTypeReference(ts, node, cb));
+    }
+}
+function collectVars(ts, node, result) {
+    if (ts.isIdentifier(node)) {
+        result.push(node.text);
+    }
+    else if (ts.isObjectBindingPattern(node)) {
+        for (const el of node.elements) {
+            collectVars(ts, el.name, result);
+        }
+    }
+    else if (ts.isArrayBindingPattern(node)) {
+        for (const el of node.elements) {
+            if (ts.isBindingElement(el)) {
+                collectVars(ts, el.name, result);
+            }
+        }
+    }
+    else {
+        node.forEachChild(node => collectVars(ts, node, result));
+    }
+}
+exports.collectVars = collectVars;
+//# sourceMappingURL=transform.js.map

node_modules/@vue/language-core/out/utils/ts.d.ts

@@ -0,0 +1,9 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type { VueCompilerOptions } from '../types';
+export type ParsedCommandLine = ts.ParsedCommandLine & {
+    vueOptions: Partial<VueCompilerOptions>;
+};
+export declare function createParsedCommandLineByJson(ts: typeof import('typescript/lib/tsserverlibrary'), parseConfigHost: ts.ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
+export declare function createParsedCommandLine(ts: typeof import('typescript/lib/tsserverlibrary'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string): ParsedCommandLine;
+export declare function resolveVueCompilerOptions(vueOptions: Partial<VueCompilerOptions>): VueCompilerOptions;
+//# sourceMappingURL=ts.d.ts.map

node_modules/@vue/language-core/out/utils/ts.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVueCompilerOptions = exports.createParsedCommandLine = exports.createParsedCommandLineByJson = void 0;
+const path = require("path-browserify");
+function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json') {
+    const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
+    ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName);
+    let vueOptions = {};
+    for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
+        try {
+            vueOptions = {
+                ...vueOptions,
+                ...getPartialVueCompilerOptions(ts, ts.readJsonConfigFile(extendPath, proxyHost.host.readFile)),
+            };
+        }
+        catch (err) { }
+    }
+    const parsed = ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName, undefined, (vueOptions.extensions ?? ['.vue']).map(extension => ({
+        extension: extension.slice(1),
+        isMixedContent: true,
+        scriptKind: ts.ScriptKind.Deferred,
+    })));
+    // fix https://github.com/vuejs/language-tools/issues/1786
+    // https://github.com/microsoft/TypeScript/issues/30457
+    // patching ts server broke with outDir + rootDir + composite/incremental
+    parsed.options.outDir = undefined;
+    return {
+        ...parsed,
+        vueOptions,
+    };
+}
+exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
+function createParsedCommandLine(ts, parseConfigHost, tsConfigPath) {
+    try {
+        const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
+        const config = ts.readJsonConfigFile(tsConfigPath, proxyHost.host.readFile);
+        ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath);
+        let vueOptions = {};
+        for (const extendPath of proxyHost.extendConfigPaths.reverse()) {
+            try {
+                vueOptions = {
+                    ...vueOptions,
+                    ...getPartialVueCompilerOptions(ts, ts.readJsonConfigFile(extendPath, proxyHost.host.readFile)),
+                };
+            }
+            catch (err) { }
+        }
+        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath, undefined, (vueOptions.extensions ?? ['.vue']).map(extension => ({
+            extension: extension.slice(1),
+            isMixedContent: true,
+            scriptKind: ts.ScriptKind.Deferred,
+        })));
+        // fix https://github.com/vuejs/language-tools/issues/1786
+        // https://github.com/microsoft/TypeScript/issues/30457
+        // patching ts server broke with outDir + rootDir + composite/incremental
+        parsed.options.outDir = undefined;
+        return {
+            ...parsed,
+            vueOptions,
+        };
+    }
+    catch (err) {
+        // console.warn('Failed to resolve tsconfig path:', tsConfigPath, err);
+        return {
+            fileNames: [],
+            options: {},
+            vueOptions: resolveVueCompilerOptions({}),
+            errors: [],
+        };
+    }
+}
+exports.createParsedCommandLine = createParsedCommandLine;
+function proxyParseConfigHostForExtendConfigPaths(parseConfigHost) {
+    const extendConfigPaths = [];
+    const host = new Proxy(parseConfigHost, {
+        get(target, key) {
+            if (key === 'readFile') {
+                return (fileName) => {
+                    if (!fileName.endsWith('/package.json') && !extendConfigPaths.includes(fileName)) {
+                        extendConfigPaths.push(fileName);
+                    }
+                    return target.readFile(fileName);
+                };
+            }
+            return target[key];
+        }
+    });
+    return {
+        host,
+        extendConfigPaths,
+    };
+}
+function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
+    const folder = path.dirname(tsConfigSourceFile.fileName);
+    const obj = ts.convertToObject(tsConfigSourceFile, []);
+    const rawOptions = obj?.vueCompilerOptions ?? {};
+    const result = {
+        ...rawOptions,
+    };
+    const target = rawOptions.target ?? 'auto';
+    if (target === 'auto') {
+        const resolvedPath = resolvePath('vue/package.json');
+        if (resolvedPath) {
+            const vuePackageJson = require(resolvedPath);
+            const versionNumbers = vuePackageJson.version.split('.');
+            result.target = Number(versionNumbers[0] + '.' + versionNumbers[1]);
+        }
+        else {
+            // console.warn('Load vue/package.json failed from', folder);
+        }
+    }
+    else {
+        result.target = target;
+    }
+    if (rawOptions.plugins) {
+        const plugins = rawOptions.plugins
+            .map((pluginPath) => {
+            try {
+                const resolvedPath = resolvePath(pluginPath);
+                if (resolvedPath) {
+                    return require(resolvedPath);
+                }
+                else {
+                    console.warn('Load plugin failed:', pluginPath);
+                }
+            }
+            catch (error) {
+                console.warn('Load plugin failed:', pluginPath, error);
+            }
+            return [];
+        })
+            .flat(Infinity);
+        result.plugins = plugins;
+    }
+    if (rawOptions.hooks) {
+        result.hooks = rawOptions.hooks
+            .map(resolvePath)
+            .filter((hook) => !!hook);
+    }
+    if (rawOptions.experimentalAdditionalLanguageModules) {
+        result.experimentalAdditionalLanguageModules = rawOptions.experimentalAdditionalLanguageModules
+            .map(resolvePath)
+            .filter((module) => !!module);
+    }
+    return result;
+    function resolvePath(scriptPath) {
+        try {
+            if (require?.resolve) {
+                return require.resolve(scriptPath, { paths: [folder] });
+            }
+            else {
+                // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
+            }
+        }
+        catch (error) {
+            // console.warn(error);
+        }
+    }
+}
+// https://developer.mozilla.org/en-US/docs/Web/HTML/Element
+const HTML_TAGS = 'html,body,base,head,link,meta,style,title,address,article,aside,footer,' +
+    'header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,' +
+    'figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,' +
+    'data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,' +
+    'time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,' +
+    'canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,' +
+    'th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,' +
+    'option,output,progress,select,textarea,details,dialog,menu,' +
+    'summary,template,blockquote,iframe,tfoot';
+// https://developer.mozilla.org/en-US/docs/Web/SVG/Element
+const SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,' +
+    'defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,' +
+    'feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,' +
+    'feDistanceLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,' +
+    'feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,' +
+    'fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,' +
+    'foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,' +
+    'mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,' +
+    'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +
+    'text,textPath,title,tspan,unknown,use,view';
+function resolveVueCompilerOptions(vueOptions) {
+    const target = vueOptions.target ?? 3.3;
+    const lib = vueOptions.lib || (target < 2.7 ? '@vue/runtime-dom' : 'vue');
+    return {
+        ...vueOptions,
+        target,
+        extensions: vueOptions.extensions ?? ['.vue'],
+        lib,
+        jsxSlots: vueOptions.jsxSlots ?? false,
+        strictTemplates: vueOptions.strictTemplates ?? false,
+        skipTemplateCodegen: vueOptions.skipTemplateCodegen ?? false,
+        nativeTags: vueOptions.nativeTags ?? [...new Set([
+                ...HTML_TAGS.split(','),
+                ...SVG_TAGS.split(','),
+                // fix https://github.com/johnsoncodehk/volar/issues/1340
+                'hgroup',
+                'slot',
+                'component',
+            ])],
+        dataAttributes: vueOptions.dataAttributes ?? [],
+        htmlAttributes: vueOptions.htmlAttributes ?? ['aria-*'],
+        optionsWrapper: vueOptions.optionsWrapper ?? (target >= 2.7
+            ? [`(await import('${lib}')).defineComponent(`, `)`]
+            : [`(await import('vue')).default.extend(`, `)`]),
+        macros: {
+            defineProps: ['defineProps'],
+            defineSlots: ['defineSlots'],
+            defineEmits: ['defineEmits'],
+            defineExpose: ['defineExpose'],
+            defineModel: ['defineModel'],
+            defineOptions: ['defineOptions'],
+            withDefaults: ['withDefaults'],
+            ...vueOptions.macros,
+        },
+        plugins: vueOptions.plugins ?? [],
+        hooks: vueOptions.hooks ?? [],
+        // experimental
+        experimentalDefinePropProposal: vueOptions.experimentalDefinePropProposal ?? false,
+        experimentalAdditionalLanguageModules: vueOptions.experimentalAdditionalLanguageModules ?? [],
+        experimentalResolveStyleCssClasses: vueOptions.experimentalResolveStyleCssClasses ?? 'scoped',
+        // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
+        // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
+        experimentalModelPropName: vueOptions.experimentalModelPropName ?? {
+            '': {
+                input: true
+            },
+            value: {
+                input: { type: 'text' },
+                textarea: true,
+                select: true
+            }
+        },
+        experimentalUseElementAccessInTemplate: vueOptions.experimentalUseElementAccessInTemplate ?? false,
+    };
+}
+exports.resolveVueCompilerOptions = resolveVueCompilerOptions;
+//# sourceMappingURL=ts.js.map

node_modules/@vue/language-core/out/utils/vue2TemplateCompiler.d.ts

@@ -0,0 +1,3 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+export declare function compile(template: string, options?: CompilerDOM.CompilerOptions): CompilerDOM.CodegenResult;
+//# sourceMappingURL=vue2TemplateCompiler.d.ts.map

node_modules/@vue/language-core/out/utils/vue2TemplateCompiler.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = void 0;
+const CompilerDOM = require("@vue/compiler-dom");
+const Vue2TemplateCompiler = require('vue-template-compiler/build');
+function compile(template, options = {}) {
+    const onError = options.onError;
+    const onWarn = options.onWarn;
+    options.onError = (error) => {
+        if (error.code === 33 // :key binding allowed in v-for template child in vue 2
+            || error.code === 29 // fix https://github.com/vuejs/language-tools/issues/1638
+        ) {
+            return;
+        }
+        if (onError) {
+            onError(error);
+        }
+        else {
+            throw error;
+        }
+    };
+    const vue2Result = Vue2TemplateCompiler.compile(template, { outputSourceRange: true });
+    for (const error of vue2Result.errors) {
+        onError?.({
+            code: 'vue-template-compiler',
+            name: '',
+            message: error.msg,
+            loc: {
+                source: '',
+                start: { column: -1, line: -1, offset: error.start },
+                end: { column: -1, line: -1, offset: error.end ?? error.start },
+            },
+        });
+    }
+    for (const error of vue2Result.tips) {
+        onWarn?.({
+            code: 'vue-template-compiler',
+            name: '',
+            message: error.msg,
+            loc: {
+                source: '',
+                start: { column: -1, line: -1, offset: error.start },
+                end: { column: -1, line: -1, offset: error.end ?? error.start },
+            },
+        });
+    }
+    return baseCompile(template, Object.assign({}, CompilerDOM.parserOptions, options, {
+        nodeTransforms: [
+            ...CompilerDOM.DOMNodeTransforms,
+            ...(options.nodeTransforms || [])
+        ],
+        directiveTransforms: Object.assign({}, CompilerDOM.DOMDirectiveTransforms, options.directiveTransforms || {}),
+    }));
+}
+exports.compile = compile;
+function baseCompile(template, options = {}) {
+    const onError = options.onError || ((error) => { throw error; });
+    const isModuleMode = options.mode === 'module';
+    const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
+    if (!prefixIdentifiers && options.cacheHandlers) {
+        onError(CompilerDOM.createCompilerError(49));
+    }
+    if (options.scopeId && !isModuleMode) {
+        onError(CompilerDOM.createCompilerError(50));
+    }
+    const ast = CompilerDOM.baseParse(template, options);
+    const [nodeTransforms, directiveTransforms] = CompilerDOM.getBaseTransformPreset(prefixIdentifiers);
+    // v-for > v-if in vue 2
+    const transformIf = nodeTransforms[1];
+    const transformFor = nodeTransforms[3];
+    nodeTransforms[1] = transformFor;
+    nodeTransforms[3] = transformIf;
+    CompilerDOM.transform(ast, Object.assign({}, options, {
+        prefixIdentifiers,
+        nodeTransforms: [
+            ...nodeTransforms,
+            ...(options.nodeTransforms || []) // user transforms
+        ],
+        directiveTransforms: Object.assign({}, directiveTransforms, options.directiveTransforms || {} // user transforms
+        )
+    }));
+    return CompilerDOM.generate(ast, Object.assign({}, options, {
+        prefixIdentifiers
+    }));
+}
+//# sourceMappingURL=vue2TemplateCompiler.js.map

node_modules/@vue/language-core/out/virtualFile/computedFiles.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFile } from '@volar/language-core';
+import type { Sfc, VueLanguagePlugin } from '../types';
+export declare function computedFiles(plugins: ReturnType<VueLanguagePlugin>[], fileName: string, sfc: Sfc, codegenStack: boolean): () => VirtualFile[];
+//# sourceMappingURL=computedFiles.d.ts.map

node_modules/@vue/language-core/out/virtualFile/computedFiles.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedFiles = void 0;
+const source_map_1 = require("@volar/source-map");
+const muggle = require("muggle-string");
+const embeddedFile_1 = require("./embeddedFile");
+const computeds_1 = require("computeds");
+function computedFiles(plugins, fileName, sfc, codegenStack) {
+    const nameToBlock = (0, computeds_1.computed)(() => {
+        const blocks = {};
+        if (sfc.template) {
+            blocks[sfc.template.name] = sfc.template;
+        }
+        if (sfc.script) {
+            blocks[sfc.script.name] = sfc.script;
+        }
+        if (sfc.scriptSetup) {
+            blocks[sfc.scriptSetup.name] = sfc.scriptSetup;
+        }
+        for (const block of sfc.styles) {
+            blocks[block.name] = block;
+        }
+        for (const block of sfc.customBlocks) {
+            blocks[block.name] = block;
+        }
+        return blocks;
+    });
+    const pluginsResult = plugins.map(plugin => compiledPluginFiles(plugins, plugin, fileName, sfc, nameToBlock, codegenStack));
+    const flatResult = (0, computeds_1.computed)(() => pluginsResult.map(r => r()).flat());
+    const structuredResult = (0, computeds_1.computed)(() => {
+        const embeddedFiles = [];
+        let remain = [...flatResult()];
+        while (remain.length) {
+            const beforeLength = remain.length;
+            consumeRemain();
+            if (beforeLength === remain.length) {
+                break;
+            }
+        }
+        for (const { file, snapshot, mappings, codegenStacks } of remain) {
+            embeddedFiles.push({
+                ...file,
+                snapshot,
+                mappings,
+                codegenStacks,
+                embeddedFiles: [],
+            });
+            console.error('Unable to resolve embedded: ' + file.parentFileName + ' -> ' + file.fileName);
+        }
+        return embeddedFiles;
+        function consumeRemain() {
+            for (let i = remain.length - 1; i >= 0; i--) {
+                const { file, snapshot, mappings, codegenStacks } = remain[i];
+                if (!file.parentFileName) {
+                    embeddedFiles.push({
+                        ...file,
+                        snapshot,
+                        mappings,
+                        codegenStacks,
+                        embeddedFiles: [],
+                    });
+                    remain.splice(i, 1);
+                }
+                else {
+                    const parent = findParentStructure(file.parentFileName, embeddedFiles);
+                    if (parent) {
+                        parent.embeddedFiles.push({
+                            ...file,
+                            snapshot,
+                            mappings,
+                            codegenStacks,
+                            embeddedFiles: [],
+                        });
+                        remain.splice(i, 1);
+                    }
+                }
+            }
+        }
+        function findParentStructure(fileName, current) {
+            for (const child of current) {
+                if (child.fileName === fileName) {
+                    return child;
+                }
+                let parent = findParentStructure(fileName, child.embeddedFiles);
+                if (parent) {
+                    return parent;
+                }
+            }
+        }
+    });
+    return structuredResult;
+}
+exports.computedFiles = computedFiles;
+function compiledPluginFiles(plugins, plugin, fileName, sfc, nameToBlock, codegenStack) {
+    const embeddedFiles = {};
+    const files = (0, computeds_1.computed)(() => {
+        try {
+            if (!plugin.getEmbeddedFileNames) {
+                return Object.values(embeddedFiles);
+            }
+            const embeddedFileNames = plugin.getEmbeddedFileNames(fileName, sfc);
+            for (const oldFileName of Object.keys(embeddedFiles)) {
+                if (!embeddedFileNames.includes(oldFileName)) {
+                    delete embeddedFiles[oldFileName];
+                }
+            }
+            for (const embeddedFileName of embeddedFileNames) {
+                if (!embeddedFiles[embeddedFileName]) {
+                    embeddedFiles[embeddedFileName] = (0, computeds_1.computed)(() => {
+                        const [content, stacks] = codegenStack ? muggle.track([]) : [[], []];
+                        const file = new embeddedFile_1.VueEmbeddedFile(embeddedFileName, content, stacks);
+                        for (const plugin of plugins) {
+                            if (!plugin.resolveEmbeddedFile) {
+                                continue;
+                            }
+                            try {
+                                plugin.resolveEmbeddedFile(fileName, sfc, file);
+                            }
+                            catch (e) {
+                                console.error(e);
+                            }
+                        }
+                        const newText = (0, source_map_1.toString)(file.content);
+                        const changeRanges = new Map();
+                        const snapshot = {
+                            getText: (start, end) => newText.slice(start, end),
+                            getLength: () => newText.length,
+                            getChangeRange(oldSnapshot) {
+                                if (!changeRanges.has(oldSnapshot)) {
+                                    changeRanges.set(oldSnapshot, undefined);
+                                    const oldText = oldSnapshot.getText(0, oldSnapshot.getLength());
+                                    const changeRange = fullDiffTextChangeRange(oldText, newText);
+                                    if (changeRange) {
+                                        changeRanges.set(oldSnapshot, changeRange);
+                                    }
+                                }
+                                return changeRanges.get(oldSnapshot);
+                            },
+                        };
+                        return {
+                            file,
+                            snapshot,
+                        };
+                    });
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return Object.values(embeddedFiles);
+    });
+    return (0, computeds_1.computed)(() => {
+        return files().map(_file => {
+            const { file, snapshot } = _file();
+            const mappings = (0, source_map_1.buildMappings)(file.content);
+            for (const mapping of mappings) {
+                if (mapping.source !== undefined) {
+                    const block = nameToBlock()[mapping.source];
+                    if (block) {
+                        mapping.sourceRange = [
+                            mapping.sourceRange[0] + block.startTagEnd,
+                            mapping.sourceRange[1] + block.startTagEnd,
+                        ];
+                    }
+                    else {
+                        // ignore
+                    }
+                    mapping.source = undefined;
+                }
+            }
+            return {
+                file,
+                snapshot,
+                mappings,
+                codegenStacks: (0, source_map_1.buildStacks)(file.content, file.contentStacks),
+            };
+        });
+    });
+}
+function fullDiffTextChangeRange(oldText, newText) {
+    for (let start = 0; start < oldText.length && start < newText.length; start++) {
+        if (oldText[start] !== newText[start]) {
+            let end = oldText.length;
+            for (let i = 0; i < oldText.length - start && i < newText.length - start; i++) {
+                if (oldText[oldText.length - i - 1] !== newText[newText.length - i - 1]) {
+                    break;
+                }
+                end--;
+            }
+            let length = end - start;
+            let newLength = length + (newText.length - oldText.length);
+            if (newLength < 0) {
+                length -= newLength;
+                newLength = 0;
+            }
+            return {
+                span: { start, length },
+                newLength,
+            };
+        }
+    }
+}
+//# sourceMappingURL=computedFiles.js.map

node_modules/@vue/language-core/out/virtualFile/computedMappings.d.ts

@@ -0,0 +1,6 @@
+import { FileRangeCapabilities } from '@volar/language-core';
+import { Mapping } from '@volar/source-map';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { Sfc } from '../types';
+export declare function computedMappings(snapshot: () => ts.IScriptSnapshot, sfc: Sfc): () => Mapping<FileRangeCapabilities>[];
+//# sourceMappingURL=computedMappings.d.ts.map

node_modules/@vue/language-core/out/virtualFile/computedMappings.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedMappings = void 0;
+const language_core_1 = require("@volar/language-core");
+const muggle = require("muggle-string");
+const computeds_1 = require("computeds");
+function computedMappings(snapshot, sfc) {
+    return (0, computeds_1.computed)(() => {
+        const str = [[snapshot().getText(0, snapshot().getLength()), undefined, 0, language_core_1.FileRangeCapabilities.full]];
+        for (const block of [
+            sfc.script,
+            sfc.scriptSetup,
+            sfc.template,
+            ...sfc.styles,
+            ...sfc.customBlocks,
+        ]) {
+            if (block) {
+                muggle.replaceSourceRange(str, undefined, block.startTagEnd, block.endTagStart, [
+                    block.content,
+                    undefined,
+                    block.startTagEnd,
+                    {},
+                ]);
+            }
+        }
+        return str.map((m) => {
+            const text = m[0];
+            const start = m[2];
+            const end = start + text.length;
+            return {
+                sourceRange: [start, end],
+                generatedRange: [start, end],
+                data: m[3],
+            };
+        });
+    });
+}
+exports.computedMappings = computedMappings;
+//# sourceMappingURL=computedMappings.js.map

node_modules/@vue/language-core/out/virtualFile/computedSfc.d.ts

@@ -0,0 +1,5 @@
+import type { SFCParseResult } from '@vue/compiler-sfc';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { Sfc, VueLanguagePlugin } from '../types';
+export declare function computedSfc(ts: typeof import('typescript/lib/tsserverlibrary'), plugins: ReturnType<VueLanguagePlugin>[], fileName: string, snapshot: () => ts.IScriptSnapshot, parsed: () => SFCParseResult | undefined): Sfc;
+//# sourceMappingURL=computedSfc.d.ts.map

node_modules/@vue/language-core/out/virtualFile/computedSfc.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedSfc = void 0;
+const parseCssClassNames_1 = require("../utils/parseCssClassNames");
+const parseCssVars_1 = require("../utils/parseCssVars");
+const computeds_1 = require("computeds");
+function computedSfc(ts, plugins, fileName, snapshot, parsed) {
+    const untrackedSnapshot = () => {
+        (0, computeds_1.pauseTracking)();
+        const res = snapshot();
+        (0, computeds_1.resetTracking)();
+        return res;
+    };
+    const template = computedNullableSfcBlock('template', 'html', (0, computeds_1.computed)(() => parsed()?.descriptor.template ?? undefined), (_block, base) => {
+        const compiledAst = computedTemplateAst(base);
+        return mergeObject(base, {
+            get ast() { return compiledAst()?.ast; },
+            get errors() { return compiledAst()?.errors; },
+            get warnings() { return compiledAst()?.warnings; },
+        });
+    });
+    const script = computedNullableSfcBlock('script', 'js', (0, computeds_1.computed)(() => parsed()?.descriptor.script ?? undefined), (block, base) => {
+        const src = (0, computeds_1.computed)(() => block().src);
+        const srcOffset = (0, computeds_1.computed)(() => {
+            const _src = src();
+            return _src ? untrackedSnapshot().getText(0, base.startTagEnd).lastIndexOf(_src) - base.startTagEnd : -1;
+        });
+        const ast = (0, computeds_1.computed)(() => ts.createSourceFile(fileName + '.' + base.lang, base.content, ts.ScriptTarget.Latest));
+        return mergeObject(base, {
+            get src() { return src(); },
+            get srcOffset() { return srcOffset(); },
+            get ast() { return ast(); },
+        });
+    });
+    const scriptSetup = computedNullableSfcBlock('scriptSetup', 'js', (0, computeds_1.computed)(() => parsed()?.descriptor.scriptSetup ?? undefined), (block, base) => {
+        const generic = (0, computeds_1.computed)(() => {
+            const _block = block();
+            return typeof _block.attrs.generic === 'string' ? _block.attrs.generic : undefined;
+        });
+        const genericOffset = (0, computeds_1.computed)(() => {
+            const _generic = generic();
+            return _generic !== undefined ? untrackedSnapshot().getText(0, base.startTagEnd).lastIndexOf(_generic) - base.startTagEnd : -1;
+        });
+        const ast = (0, computeds_1.computed)(() => ts.createSourceFile(fileName + '.' + base.lang, base.content, ts.ScriptTarget.Latest));
+        return mergeObject(base, {
+            get generic() { return generic(); },
+            get genericOffset() { return genericOffset(); },
+            get ast() { return ast(); },
+        });
+    });
+    const styles = (0, computeds_1.computedArray)((0, computeds_1.computed)(() => parsed()?.descriptor.styles ?? []), (block, i) => {
+        const base = computedSfcBlock('style_' + i, 'css', block);
+        const module = (0, computeds_1.computed)(() => typeof block().module === 'string' ? block().module : block().module ? '$style' : undefined);
+        const scoped = (0, computeds_1.computed)(() => !!block().scoped);
+        const cssVars = (0, computeds_1.computed)(() => [...(0, parseCssVars_1.parseCssVars)(base.content)]);
+        const classNames = (0, computeds_1.computed)(() => [...(0, parseCssClassNames_1.parseCssClassNames)(base.content)]);
+        return (0, computeds_1.computed)(() => mergeObject(base, {
+            get module() { return module(); },
+            get scoped() { return scoped(); },
+            get cssVars() { return cssVars(); },
+            get classNames() { return classNames(); },
+        }));
+    });
+    const customBlocks = (0, computeds_1.computedArray)((0, computeds_1.computed)(() => parsed()?.descriptor.customBlocks ?? []), (block, i) => {
+        const base = computedSfcBlock('customBlock_' + i, 'txt', block);
+        const type = (0, computeds_1.computed)(() => block().type);
+        return (0, computeds_1.computed)(() => mergeObject(base, {
+            get type() { return type(); },
+        }));
+    });
+    return {
+        get template() { return template(); },
+        get script() { return script(); },
+        get scriptSetup() { return scriptSetup(); },
+        get styles() { return styles; },
+        get customBlocks() { return customBlocks; },
+        get templateAst() { return template()?.ast; },
+        get scriptAst() { return script()?.ast; },
+        get scriptSetupAst() { return scriptSetup()?.ast; },
+    };
+    function computedTemplateAst(base) {
+        let cache;
+        return (0, computeds_1.computed)(() => {
+            if (cache?.template === base.content) {
+                return {
+                    errors: [],
+                    warnings: [],
+                    ast: cache?.result.ast,
+                };
+            }
+            // incremental update
+            if (cache?.plugin.updateSFCTemplate) {
+                const change = untrackedSnapshot().getChangeRange(cache.snapshot);
+                if (change) {
+                    (0, computeds_1.pauseTracking)();
+                    const templateOffset = base.startTagEnd;
+                    (0, computeds_1.resetTracking)();
+                    const newText = untrackedSnapshot().getText(change.span.start, change.span.start + change.newLength);
+                    const newResult = cache.plugin.updateSFCTemplate(cache.result, {
+                        start: change.span.start - templateOffset,
+                        end: change.span.start + change.span.length - templateOffset,
+                        newText,
+                    });
+                    if (newResult) {
+                        cache.template = base.content;
+                        cache.snapshot = untrackedSnapshot();
+                        cache.result = newResult;
+                        return {
+                            errors: [],
+                            warnings: [],
+                            ast: newResult.ast,
+                        };
+                    }
+                }
+            }
+            const errors = [];
+            const warnings = [];
+            let options = {
+                onError: (err) => errors.push(err),
+                onWarn: (err) => warnings.push(err),
+                expressionPlugins: ['typescript'],
+            };
+            for (const plugin of plugins) {
+                if (plugin.resolveTemplateCompilerOptions) {
+                    options = plugin.resolveTemplateCompilerOptions(options);
+                }
+            }
+            for (const plugin of plugins) {
+                let result;
+                try {
+                    result = plugin.compileSFCTemplate?.(base.lang, base.content, options);
+                }
+                catch (e) {
+                    const err = e;
+                    errors.push(err);
+                }
+                if (result || errors.length) {
+                    if (result && !errors.length && !warnings.length) {
+                        cache = {
+                            template: base.content,
+                            snapshot: untrackedSnapshot(),
+                            result: result,
+                            plugin,
+                        };
+                    }
+                    else {
+                        cache = undefined;
+                    }
+                    return {
+                        errors,
+                        warnings,
+                        ast: result?.ast,
+                    };
+                }
+            }
+            return {
+                errors,
+                warnings,
+                ast: undefined,
+            };
+        });
+    }
+    function computedNullableSfcBlock(name, defaultLang, block, resolve) {
+        const hasBlock = (0, computeds_1.computed)(() => !!block());
+        return (0, computeds_1.computed)(() => {
+            if (!hasBlock()) {
+                return;
+            }
+            const _block = (0, computeds_1.computed)(() => block());
+            return resolve(_block, computedSfcBlock(name, defaultLang, _block));
+        });
+    }
+    function computedSfcBlock(name, defaultLang, block) {
+        const lang = (0, computeds_1.computed)(() => block().lang ?? defaultLang);
+        const attrs = (0, computeds_1.computed)(() => block().attrs); // TODO: computed it
+        const content = (0, computeds_1.computed)(() => block().content);
+        const startTagEnd = (0, computeds_1.computed)(() => block().loc.start.offset);
+        const endTagStart = (0, computeds_1.computed)(() => block().loc.end.offset);
+        const start = (0, computeds_1.computed)(() => untrackedSnapshot().getText(0, startTagEnd()).lastIndexOf('<' + block().type));
+        const end = (0, computeds_1.computed)(() => endTagStart() + untrackedSnapshot().getText(endTagStart(), untrackedSnapshot().getLength()).indexOf('>') + 1);
+        return {
+            name,
+            get lang() { return lang(); },
+            get attrs() { return attrs(); },
+            get content() { return content(); },
+            get startTagEnd() { return startTagEnd(); },
+            get endTagStart() { return endTagStart(); },
+            get start() { return start(); },
+            get end() { return end(); },
+        };
+    }
+}
+exports.computedSfc = computedSfc;
+function mergeObject(a, b) {
+    return Object.defineProperties(a, Object.getOwnPropertyDescriptors(b));
+}
+//# sourceMappingURL=computedSfc.js.map

node_modules/@vue/language-core/out/virtualFile/computedVueSfc.d.ts

@@ -0,0 +1,5 @@
+import type { SFCParseResult } from '@vue/compiler-sfc';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { VueLanguagePlugin } from '../types';
+export declare function computedVueSfc(plugins: ReturnType<VueLanguagePlugin>[], fileName: string, snapshot: () => ts.IScriptSnapshot): () => SFCParseResult | undefined;
+//# sourceMappingURL=computedVueSfc.d.ts.map

node_modules/@vue/language-core/out/virtualFile/computedVueSfc.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedVueSfc = void 0;
+const computeds_1 = require("computeds");
+function computedVueSfc(plugins, fileName, snapshot) {
+    let cache;
+    return (0, computeds_1.computed)(() => {
+        // incremental update
+        if (cache?.plugin.updateSFC) {
+            const change = snapshot().getChangeRange(cache.snapshot);
+            if (change) {
+                const newSfc = cache.plugin.updateSFC(cache.sfc, {
+                    start: change.span.start,
+                    end: change.span.start + change.span.length,
+                    newText: snapshot().getText(change.span.start, change.span.start + change.newLength),
+                });
+                if (newSfc) {
+                    cache.snapshot = snapshot();
+                    // force dirty
+                    cache.sfc = JSON.parse(JSON.stringify(newSfc));
+                    return cache.sfc;
+                }
+            }
+        }
+        for (const plugin of plugins) {
+            const sfc = plugin.parseSFC?.(fileName, snapshot().getText(0, snapshot().getLength()));
+            if (sfc) {
+                if (!sfc.errors.length) {
+                    cache = {
+                        snapshot: snapshot(),
+                        sfc,
+                        plugin,
+                    };
+                }
+                return sfc;
+            }
+        }
+    });
+}
+exports.computedVueSfc = computedVueSfc;
+//# sourceMappingURL=computedVueSfc.js.map

node_modules/@vue/language-core/out/virtualFile/embeddedFile.d.ts

@@ -0,0 +1,13 @@
+import { FileCapabilities, FileKind, FileRangeCapabilities, MirrorBehaviorCapabilities } from '@volar/language-core';
+import { Mapping, Segment, StackNode } from '@volar/source-map';
+export declare class VueEmbeddedFile {
+    fileName: string;
+    content: Segment<FileRangeCapabilities>[];
+    contentStacks: StackNode[];
+    parentFileName?: string;
+    kind: FileKind;
+    capabilities: FileCapabilities;
+    mirrorBehaviorMappings: Mapping<[MirrorBehaviorCapabilities, MirrorBehaviorCapabilities]>[];
+    constructor(fileName: string, content: Segment<FileRangeCapabilities>[], contentStacks: StackNode[]);
+}
+//# sourceMappingURL=embeddedFile.d.ts.map

node_modules/@vue/language-core/out/virtualFile/embeddedFile.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VueEmbeddedFile = void 0;
+const language_core_1 = require("@volar/language-core");
+class VueEmbeddedFile {
+    constructor(fileName, content, contentStacks) {
+        this.fileName = fileName;
+        this.content = content;
+        this.contentStacks = contentStacks;
+        this.kind = language_core_1.FileKind.TextFile;
+        this.capabilities = {};
+        this.mirrorBehaviorMappings = [];
+    }
+}
+exports.VueEmbeddedFile = VueEmbeddedFile;
+//# sourceMappingURL=embeddedFile.js.map

node_modules/@vue/language-core/out/virtualFile/vueFile.d.ts

@@ -0,0 +1,28 @@
+import { FileCapabilities, FileKind, VirtualFile } from '@volar/language-core';
+import { Stack } from '@volar/source-map';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { VueCompilerOptions, VueLanguagePlugin } from '../types';
+import { Signal } from 'computeds';
+export declare class VueFile implements VirtualFile {
+    fileName: string;
+    initSnapshot: ts.IScriptSnapshot;
+    vueCompilerOptions: VueCompilerOptions;
+    plugins: ReturnType<VueLanguagePlugin>[];
+    ts: typeof import('typescript/lib/tsserverlibrary');
+    codegenStack: boolean;
+    _snapshot: Signal<ts.IScriptSnapshot>;
+    getVueSfc: () => import("@vue/compiler-sfc").SFCParseResult | undefined;
+    sfc: import("../types").Sfc;
+    getMappings: () => import("@volar/source-map").Mapping<import("@volar/language-core").FileRangeCapabilities>[];
+    getEmbeddedFiles: () => VirtualFile[];
+    capabilities: FileCapabilities;
+    kind: FileKind;
+    codegenStacks: Stack[];
+    get embeddedFiles(): VirtualFile[];
+    get mainScriptName(): string;
+    get snapshot(): ts.IScriptSnapshot;
+    get mappings(): import("@volar/source-map").Mapping<import("@volar/language-core").FileRangeCapabilities>[];
+    constructor(fileName: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: ReturnType<VueLanguagePlugin>[], ts: typeof import('typescript/lib/tsserverlibrary'), codegenStack: boolean);
+    update(newSnapshot: ts.IScriptSnapshot): void;
+}
+//# sourceMappingURL=vueFile.d.ts.map

node_modules/@vue/language-core/out/virtualFile/vueFile.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VueFile = void 0;
+const language_core_1 = require("@volar/language-core");
+const computedFiles_1 = require("./computedFiles");
+const computedMappings_1 = require("./computedMappings");
+const computedSfc_1 = require("./computedSfc");
+const computedVueSfc_1 = require("./computedVueSfc");
+const computeds_1 = require("computeds");
+const jsxReg = /^\.(js|ts)x?$/;
+class VueFile {
+    get embeddedFiles() {
+        return this.getEmbeddedFiles();
+    }
+    get mainScriptName() {
+        let res = '';
+        (0, language_core_1.forEachEmbeddedFile)(this, file => {
+            if (file.kind === language_core_1.FileKind.TypeScriptHostFile && file.fileName.replace(this.fileName, '').match(jsxReg)) {
+                res = file.fileName;
+            }
+        });
+        return res;
+    }
+    get snapshot() {
+        return this._snapshot();
+    }
+    get mappings() {
+        return this.getMappings();
+    }
+    constructor(fileName, initSnapshot, vueCompilerOptions, plugins, ts, codegenStack) {
+        this.fileName = fileName;
+        this.initSnapshot = initSnapshot;
+        this.vueCompilerOptions = vueCompilerOptions;
+        this.plugins = plugins;
+        this.ts = ts;
+        this.codegenStack = codegenStack;
+        // computeds
+        this.getVueSfc = (0, computedVueSfc_1.computedVueSfc)(this.plugins, this.fileName, () => this._snapshot());
+        this.sfc = (0, computedSfc_1.computedSfc)(this.ts, this.plugins, this.fileName, () => this._snapshot(), this.getVueSfc);
+        this.getMappings = (0, computedMappings_1.computedMappings)(() => this._snapshot(), this.sfc);
+        this.getEmbeddedFiles = (0, computedFiles_1.computedFiles)(this.plugins, this.fileName, this.sfc, this.codegenStack);
+        // others
+        this.capabilities = language_core_1.FileCapabilities.full;
+        this.kind = language_core_1.FileKind.TextFile;
+        this.codegenStacks = [];
+        this._snapshot = (0, computeds_1.signal)(initSnapshot);
+    }
+    update(newSnapshot) {
+        this._snapshot.set(newSnapshot);
+    }
+}
+exports.VueFile = VueFile;
+//# sourceMappingURL=vueFile.js.map