@vue/language-core 1.8.18 → 1.8.20

package/out/parsers/scriptSetupRanges.js

@@ -4,23 +4,14 @@ exports.getStartEnd = exports.findBindingVars = exports.parseBindingRanges = exp
 function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     let foundNonImportExportNode = false;
     let importSectionEndOffset = 0;
-    let withDefaultsArg;
-    let propsAssignName;
-    let withDefaults;
-    let defineProps;
-    let propsRuntimeArg;
-    let propsTypeArg;
-    let defineSlots;
-    let defineEmits;
-    let defineExpose;
-    let slotsAssignName;
-    let emitsAssignName;
-    let exposeRuntimeArg;
-    let exposeTypeArg;
+    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, false);
+    const bindings = parseBindingRanges(ts, ast);
     const text = ast.getFullText();
     const leadingCommentEndOffset = ts.getLeadingCommentRanges(text, 0)?.reverse()[0].end ?? 0;
     ast.forEachChild(node => {
@@ -42,30 +33,22 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             foundNonImportExportNode = true;
         }
     });
-    ast.forEachChild(child => visitNode(child, ast));
+    ast.forEachChild(child => visitNode(child, [ast]));
     return {
         leadingCommentEndOffset,
         importSectionEndOffset,
         bindings,
-        withDefaultsArg,
-        withDefaults,
-        defineProps,
-        defineSlots,
-        defineEmits,
-        defineExpose,
-        propsAssignName,
-        propsRuntimeArg,
-        propsTypeArg,
-        slotsAssignName,
-        emitsAssignName,
-        exposeRuntimeArg,
-        exposeTypeArg,
+        props,
+        slots,
+        emits,
+        expose,
         defineProp,
     };
     function _getStartEnd(node) {
         return getStartEnd(node, ast);
     }
-    function visitNode(node, parent) {
+    function visitNode(node, parents) {
+        const parent = parents[parents.length - 1];
         if (ts.isCallExpression(node)
             && ts.isIdentifier(node.expression)) {
             const callText = node.expression.getText(ast);
@@ -145,90 +128,102 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 }
             }
             else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
-                defineSlots = _getStartEnd(node);
+                slots.define = _getStartEnd(node);
                 if (ts.isVariableDeclaration(parent)) {
-                    slotsAssignName = parent.name.getText(ast);
+                    slots.name = parent.name.getText(ast);
                 }
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
-                defineEmits = _getStartEnd(node);
+                emits.define = _getStartEnd(node);
                 if (ts.isVariableDeclaration(parent)) {
-                    emitsAssignName = parent.name.getText(ast);
+                    emits.name = parent.name.getText(ast);
                 }
             }
             else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
-                defineExpose = _getStartEnd(node);
+                expose.define = _getStartEnd(node);
                 if (node.arguments.length) {
-                    exposeRuntimeArg = _getStartEnd(node.arguments[0]);
+                    expose.define.arg = _getStartEnd(node.arguments[0]);
                 }
                 if (node.typeArguments?.length) {
-                    exposeTypeArg = _getStartEnd(node.typeArguments[0]);
+                    expose.define.typeArg = _getStartEnd(node.typeArguments[0]);
                 }
             }
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
-                defineProps = _getStartEnd(node);
+                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 = {
+                    ..._getStartEnd(node),
+                    statement: statementRange,
+                };
                 if (ts.isVariableDeclaration(parent)) {
-                    propsAssignName = parent.name.getText(ast);
+                    props.name = parent.name.getText(ast);
                 }
                 if (node.arguments.length) {
-                    propsRuntimeArg = _getStartEnd(node.arguments[0]);
+                    props.define.arg = _getStartEnd(node.arguments[0]);
                 }
                 if (node.typeArguments?.length) {
-                    propsTypeArg = _getStartEnd(node.typeArguments[0]);
+                    props.define.typeArg = _getStartEnd(node.typeArguments[0]);
                 }
             }
             else if (vueCompilerOptions.macros.withDefaults.includes(callText)) {
-                withDefaults = _getStartEnd(node);
+                props.withDefaults = _getStartEnd(node);
                 if (node.arguments.length >= 2) {
                     const arg = node.arguments[1];
-                    withDefaultsArg = _getStartEnd(arg);
+                    props.withDefaults.arg = _getStartEnd(arg);
                 }
                 if (ts.isVariableDeclaration(parent)) {
-                    propsAssignName = parent.name.getText(ast);
+                    props.name = parent.name.getText(ast);
                 }
             }
         }
-        node.forEachChild(child => visitNode(child, node));
+        node.forEachChild(child => {
+            parents.push(node);
+            visitNode(child, parents);
+            parents.pop();
+        });
     }
 }
 exports.parseScriptSetupRanges = parseScriptSetupRanges;
-function parseBindingRanges(ts, sourceFile, isType) {
+function parseBindingRanges(ts, sourceFile) {
     const bindings = [];
     sourceFile.forEachChild(node => {
-        if (!isType) {
-            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));
+        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.isClassDeclaration(node)) {
-                if (node.name) {
-                    bindings.push(_getStartEnd(node.name));
-                }
-            }
-            else if (ts.isEnumDeclaration(node)) {
-                bindings.push(_getStartEnd(node.name));
-            }
         }
-        else {
-            if (ts.isTypeAliasDeclaration(node)) {
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
                 bindings.push(_getStartEnd(node.name));
             }
-            else if (ts.isInterfaceDeclaration(node)) {
+        }
+        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 && (isType || !node.importClause.isTypeOnly)) {
-                if (node.importClause.name && !isType) {
+            if (node.importClause && !node.importClause.isTypeOnly) {
+                if (node.importClause.name) {
                     bindings.push(_getStartEnd(node.importClause.name));
                 }
                 if (node.importClause.namedBindings) {

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

@@ -1,7 +1,7 @@
 import { Sfc, VueLanguagePlugin } from '../types';
 import * as muggle from 'muggle-string';
 export declare const tsCodegen: WeakMap<Sfc, {
-    scriptRanges: import("@vue/reactivity").ComputedRef<{
+    scriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
             args: import("../types").TextRange;
@@ -11,24 +11,37 @@ export declare const tsCodegen: WeakMap<Sfc, {
             nameOption: import("../types").TextRange | undefined;
         }) | undefined;
         bindings: import("../types").TextRange[];
-    } | undefined>;
-    scriptSetupRanges: import("@vue/reactivity").ComputedRef<{
+    } | undefined;
+    scriptSetupRanges: () => {
         leadingCommentEndOffset: number;
         importSectionEndOffset: number;
         bindings: import("../types").TextRange[];
-        withDefaultsArg: import("../types").TextRange | undefined;
-        withDefaults: import("../types").TextRange | undefined;
-        defineProps: import("../types").TextRange | undefined;
-        defineSlots: import("../types").TextRange | undefined;
-        defineEmits: import("../types").TextRange | undefined;
-        defineExpose: import("../types").TextRange | undefined;
-        propsAssignName: string | undefined;
-        propsRuntimeArg: import("../types").TextRange | undefined;
-        propsTypeArg: import("../types").TextRange | undefined;
-        slotsAssignName: string | undefined;
-        emitsAssignName: string | undefined;
-        exposeRuntimeArg: import("../types").TextRange | undefined;
-        exposeTypeArg: import("../types").TextRange | undefined;
+        props: {
+            name?: string | undefined;
+            define?: (import("../types").TextRange & {
+                statement: import("../types").TextRange;
+                arg?: import("../types").TextRange | undefined;
+                typeArg?: import("../types").TextRange | undefined;
+            }) | undefined;
+            withDefaults?: (import("../types").TextRange & {
+                arg?: import("../types").TextRange | undefined;
+            }) | undefined;
+        };
+        slots: {
+            name?: string | undefined;
+            define?: import("../types").TextRange | undefined;
+        };
+        emits: {
+            name?: string | undefined;
+            define?: import("../types").TextRange | 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;
@@ -36,14 +49,14 @@ export declare const tsCodegen: WeakMap<Sfc, {
             defaultValue: import("../types").TextRange | undefined;
             required: boolean;
         }[];
-    } | undefined>;
-    lang: import("@vue/reactivity").ComputedRef<string>;
-    tsxGen: import("@vue/reactivity").ComputedRef<{
+    } | 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]>[];
-    }>;
-    htmlGen: import("@vue/reactivity").ComputedRef<{
+    };
+    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])[];
@@ -51,9 +64,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
         cssCodes: (string | [string, string | undefined, number | [number, number], import("@volar/language-core").FileRangeCapabilities])[];
         cssCodeStacks: muggle.StackNode[];
         tagNames: Record<string, number[]>;
-        identifiers: Set<string>;
+        accessedGlobalVariables: Set<string>;
         hasSlot: boolean;
-    } | undefined>;
+    } | undefined;
 }>;
 declare const plugin: VueLanguagePlugin;
 export default plugin;

package/out/plugins/vue-tsx.js

@@ -24,9 +24,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
-const reactivity_1 = require("@vue/reactivity");
+const computeds_1 = require("computeds");
 const script_1 = require("../generators/script");
-const templateGen = __importStar(require("../generators/template"));
+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");
@@ -44,8 +44,8 @@ const plugin = (ctx) => {
         getEmbeddedFileNames(fileName, sfc) {
             const tsx = useTsx(fileName, sfc);
             const fileNames = [];
-            if (['js', 'ts', 'jsx', 'tsx'].includes(tsx.lang.value)) {
-                fileNames.push(fileName + '.' + tsx.lang.value);
+            if (['js', 'ts', 'jsx', 'tsx'].includes(tsx.lang())) {
+                fileNames.push(fileName + '.' + tsx.lang());
             }
             if (sfc.template) {
                 fileNames.push(fileName + '.template_format.ts');
@@ -56,7 +56,7 @@ const plugin = (ctx) => {
         resolveEmbeddedFile(fileName, sfc, embeddedFile) {
             const _tsx = useTsx(fileName, sfc);
             const suffix = embeddedFile.fileName.replace(fileName, '');
-            if (suffix === '.' + _tsx.lang.value) {
+            if (suffix === '.' + _tsx.lang()) {
                 embeddedFile.kind = language_core_1.FileKind.TypeScriptHostFile;
                 embeddedFile.capabilities = {
                     ...language_core_1.FileCapabilities.full,
@@ -64,7 +64,7 @@ const plugin = (ctx) => {
                     documentFormatting: false,
                     documentSymbol: false,
                 };
-                const tsx = _tsx.tsxGen.value;
+                const tsx = _tsx.generatedScript();
                 if (tsx) {
                     const [content, contentStacks] = ctx.codegenStack ? muggle.track([...tsx.codes], [...tsx.codeStacks]) : [[...tsx.codes], [...tsx.codeStacks]];
                     embeddedFile.content = content;
@@ -82,8 +82,11 @@ const plugin = (ctx) => {
                     codeAction: false,
                     inlayHint: false,
                 };
-                if (_tsx.htmlGen.value) {
-                    const [content, contentStacks] = ctx.codegenStack ? muggle.track([..._tsx.htmlGen.value.formatCodes], [..._tsx.htmlGen.value.formatCodeStacks]) : [[..._tsx.htmlGen.value.formatCodes], [..._tsx.htmlGen.value.formatCodeStacks]];
+                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;
                 }
@@ -103,8 +106,11 @@ const plugin = (ctx) => {
             }
             else if (suffix.match(templateStyleCssReg)) {
                 embeddedFile.parentFileName = fileName + '.template.' + sfc.template?.lang;
-                if (_tsx.htmlGen.value) {
-                    const [content, contentStacks] = ctx.codegenStack ? muggle.track([..._tsx.htmlGen.value.cssCodes], [..._tsx.htmlGen.value.cssCodeStacks]) : [[..._tsx.htmlGen.value.cssCodes], [..._tsx.htmlGen.value.cssCodeStacks]];
+                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;
                 }
@@ -123,40 +129,54 @@ const plugin = (ctx) => {
 exports.default = plugin;
 function createTsx(fileName, _sfc, { vueCompilerOptions, compilerOptions, codegenStack, modules }) {
     const ts = modules.typescript;
-    const lang = (0, reactivity_1.computed)(() => {
+    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, reactivity_1.computed)(() => _sfc.scriptAst
-        ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.scriptAst, !!_sfc.scriptSetup, false)
+    const scriptRanges = (0, computeds_1.computed)(() => _sfc.script
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.script.ast, !!_sfc.scriptSetup, false)
         : undefined);
-    const scriptSetupRanges = (0, reactivity_1.computed)(() => _sfc.scriptSetupAst
-        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetupAst, vueCompilerOptions)
+    const scriptSetupRanges = (0, computeds_1.computed)(() => _sfc.scriptSetup
+        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, vueCompilerOptions)
         : undefined);
-    const htmlGen = (0, reactivity_1.computed)(() => {
-        if (!_sfc.templateAst)
-            return;
-        return templateGen.generate(ts, compilerOptions, vueCompilerOptions, _sfc.template?.content ?? '', _sfc.template?.lang ?? 'html', _sfc, hasScriptSetupSlots.value, slotsAssignName.value, propsAssignName.value, codegenStack);
+    const shouldGenerateScopedClasses = (0, computeds_1.computed)(() => {
+        const option = vueCompilerOptions.experimentalResolveStyleCssClasses;
+        return _sfc.styles.some(s => {
+            return option === 'always' || (option === 'scoped' && s.scoped);
+        });
     });
-    //#region remove when https://github.com/vuejs/core/pull/5912 merged
-    const hasScriptSetupSlots = (0, reactivity_1.shallowRef)(false);
-    const slotsAssignName = (0, reactivity_1.shallowRef)();
-    const propsAssignName = (0, reactivity_1.shallowRef)();
-    //#endregion
-    const tsxGen = (0, reactivity_1.computed)(() => {
-        hasScriptSetupSlots.value = !!scriptSetupRanges.value?.defineSlots;
-        slotsAssignName.value = scriptSetupRanges.value?.slotsAssignName;
-        propsAssignName.value = scriptSetupRanges.value?.propsAssignName;
-        return (0, script_1.generate)(ts, fileName, _sfc, lang.value, scriptRanges.value, scriptSetupRanges.value, htmlGen.value, compilerOptions, vueCompilerOptions, codegenStack);
+    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,
-        tsxGen,
-        htmlGen,
+        generatedScript,
+        generatedTemplate,
     };
 }
 //# sourceMappingURL=vue-tsx.js.map

package/out/plugins.d.ts

@@ -20,6 +20,6 @@ export declare function getDefaultVueLanguagePlugins(ts: typeof import('typescri
         newText: string;
     }): CompilerDOM.CodegenResult | undefined;
     getEmbeddedFileNames?(fileName: string, sfc: import("./types").Sfc): string[];
-    resolveEmbeddedFile?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./sourceFile").VueEmbeddedFile): void;
+    resolveEmbeddedFile?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./virtualFile/embeddedFile").VueEmbeddedFile): void;
 }[];
 //# sourceMappingURL=plugins.d.ts.map

package/out/types.d.ts

@@ -1,7 +1,7 @@
 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 './sourceFile';
+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;
@@ -75,16 +75,22 @@ export interface SfcBlock {
     attrs: Record<string, string | true>;
 }
 export interface Sfc {
-    template: SfcBlock | null;
+    template: SfcBlock & {
+        ast: CompilerDOM.RootNode | undefined;
+        errors: CompilerDOM.CompilerError[];
+        warnings: CompilerDOM.CompilerError[];
+    } | undefined;
     script: (SfcBlock & {
         src: string | undefined;
         srcOffset: number;
-    }) | null;
+        ast: ts.SourceFile;
+    }) | undefined;
     scriptSetup: SfcBlock & {
         generic: string | undefined;
         genericOffset: number;
-    } | null;
-    styles: (SfcBlock & {
+        ast: ts.SourceFile;
+    } | undefined;
+    styles: readonly (SfcBlock & {
         module: string | undefined;
         scoped: boolean;
         cssVars: {
@@ -96,11 +102,20 @@ export interface Sfc {
             offset: number;
         }[];
     })[];
-    customBlocks: (SfcBlock & {
+    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 {

package/out/utils/globalTypes.js

@@ -15,6 +15,11 @@ 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, {}>
@@ -27,6 +32,8 @@ type __VLS_GlobalComponents =
 		| '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][];

package/out/utils/transform.d.ts

@@ -1,9 +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: Record<string, number>, identifiers: Set<string>, vueOptions: VueCompilerOptions): {
+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 colletVars(ts: typeof import('typescript/lib/tsserverlibrary'), node: ts.Node, result: string[]): void;
+export declare function collectVars(ts: typeof import('typescript/lib/tsserverlibrary'), node: ts.Node, result: string[]): void;
 //# sourceMappingURL=transform.d.ts.map

package/out/utils/transform.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.colletVars = exports.walkInterpolationFragment = void 0;
+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[id.text] ||
+        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' ||
@@ -99,9 +99,9 @@ function walkIdentifiers(ts, node, cb, localVars, blockVars = [], isRoot = true)
         walkIdentifiers(ts, node.expression, cb, localVars, blockVars, false);
     }
     else if (ts.isVariableDeclaration(node)) {
-        colletVars(ts, node.name, blockVars);
+        collectVars(ts, node.name, blockVars);
         for (const varName of blockVars) {
-            localVars[varName] = (localVars[varName] ?? 0) + 1;
+            localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
         }
         if (node.initializer)
             walkIdentifiers(ts, node.initializer, cb, localVars, blockVars, false);
@@ -109,16 +109,16 @@ function walkIdentifiers(ts, node, cb, localVars, blockVars = [], isRoot = true)
     else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
         const functionArgs = [];
         for (const param of node.parameters) {
-            colletVars(ts, param.name, functionArgs);
+            collectVars(ts, param.name, functionArgs);
             if (param.type) {
                 walkIdentifiers(ts, param.type, cb, localVars, blockVars, false);
             }
         }
         for (const varName of functionArgs)
-            localVars[varName] = (localVars[varName] ?? 0) + 1;
+            localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
         walkIdentifiers(ts, node.body, cb, localVars, blockVars, false);
         for (const varName of functionArgs)
-            localVars[varName]--;
+            localVars.set(varName, localVars.get(varName) - 1);
     }
     else if (ts.isObjectLiteralExpression(node)) {
         for (const prop of node.properties) {
@@ -152,14 +152,14 @@ function walkIdentifiers(ts, node, cb, localVars, blockVars = [], isRoot = true)
         node.forEachChild(node => walkIdentifiers(ts, node, cb, localVars, blockVars, false));
         if (ts.isBlock(node)) {
             for (const varName of blockVars) {
-                localVars[varName]--;
+                localVars.set(varName, localVars.get(varName) - 1);
             }
         }
         blockVars = _blockVars;
     }
     if (isRoot) {
         for (const varName of blockVars) {
-            localVars[varName]--;
+            localVars.set(varName, localVars.get(varName) - 1);
         }
     }
 }
@@ -171,25 +171,25 @@ function walkIdentifiersInTypeReference(ts, node, cb) {
         node.forEachChild(node => walkIdentifiersInTypeReference(ts, node, cb));
     }
 }
-function colletVars(ts, node, result) {
+function collectVars(ts, node, result) {
     if (ts.isIdentifier(node)) {
         result.push(node.text);
     }
     else if (ts.isObjectBindingPattern(node)) {
         for (const el of node.elements) {
-            colletVars(ts, el.name, result);
+            collectVars(ts, el.name, result);
         }
     }
     else if (ts.isArrayBindingPattern(node)) {
         for (const el of node.elements) {
             if (ts.isBindingElement(el)) {
-                colletVars(ts, el.name, result);
+                collectVars(ts, el.name, result);
             }
         }
     }
     else {
-        node.forEachChild(node => colletVars(ts, node, result));
+        node.forEachChild(node => collectVars(ts, node, result));
     }
 }
-exports.colletVars = colletVars;
+exports.collectVars = collectVars;
 //# sourceMappingURL=transform.js.map

package/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