@vue/language-core 2.0.5 → 2.0.7

package/lib/generators/script.js

@@ -173,19 +173,25 @@ const __VLS_intrinsicElements: __VLS_IntrinsicElements;
 function __VLS_getVForSourceType(source: number): [number, number, number][];
 function __VLS_getVForSourceType(source: string): [string, number, number][];
 function __VLS_getVForSourceType<T extends any[]>(source: T): [
-	T[number], // item
-	number, // key
-	number, // index
+	item: T[number],
+	key: number,
+	index: number,
 ][];
 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
+	item: T extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never, 
+	key: number,
+	index: undefined,
+][];
+// #3845
+function __VLS_getVForSourceType<T extends number | { [Symbol.iterator](): Iterator<any> }>(source: T): [
+	item: number | (Exclude<T, number> extends { [Symbol.iterator](): Iterator<infer T1> } ? T1 : never), 
+	key: number,
+	index: undefined,
 ][];
 function __VLS_getVForSourceType<T>(source: T): [
-	T[keyof T], // item
-	keyof T, // key
-	number, // index
+	item: T[keyof T],
+	key: keyof T,
+	index: number,
 ][];
 
 // @ts-ignore
@@ -284,17 +290,22 @@ type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
         }
     }
     function* generateSrc() {
-        if (!script?.src)
+        if (!script?.src) {
             return;
+        }
         let src = script.src;
-        if (src.endsWith('.d.ts'))
+        if (src.endsWith('.d.ts')) {
             src = src.substring(0, src.length - '.d.ts'.length);
-        else if (src.endsWith('.ts'))
+        }
+        else if (src.endsWith('.ts')) {
             src = src.substring(0, src.length - '.ts'.length);
-        else if (src.endsWith('.tsx'))
+        }
+        else if (src.endsWith('.tsx')) {
             src = src.substring(0, src.length - '.tsx'.length) + '.jsx';
-        if (!src.endsWith('.js') && !src.endsWith('.jsx'))
+        }
+        if (!src.endsWith('.js') && !src.endsWith('.jsx')) {
             src = src + '.js';
+        }
         yield _(`export * from `);
         yield _([
             `'${src}'`,
@@ -325,15 +336,19 @@ type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
         yield _(`export { default } from '${src}';\n`);
     }
     function* generateScriptContentBeforeExportDefault() {
-        if (!script)
+        if (!script) {
             return;
-        if (!!scriptSetup && scriptRanges?.exportDefault)
+        }
+        if (!!scriptSetup && scriptRanges?.exportDefault) {
             return yield _(generateSourceCode(script, 0, scriptRanges.exportDefault.expression.start));
+        }
         let isExportRawObject = false;
-        if (scriptRanges?.exportDefault)
+        if (scriptRanges?.exportDefault) {
             isExportRawObject = script.content.substring(scriptRanges.exportDefault.expression.start, scriptRanges.exportDefault.expression.end).startsWith('{');
-        if (!isExportRawObject || !vueCompilerOptions.optionsWrapper.length || !scriptRanges?.exportDefault)
+        }
+        if (!isExportRawObject || !vueCompilerOptions.optionsWrapper.length || !scriptRanges?.exportDefault) {
             return yield _(generateSourceCode(script, 0, script.content.length));
+        }
         yield _(generateSourceCode(script, 0, scriptRanges.exportDefault.expression.start));
         yield _(vueCompilerOptions.optionsWrapper[0]);
         yield _(['', 'script', scriptRanges.exportDefault.expression.start, (0, utils_1.disableAllFeatures)({
@@ -358,14 +373,17 @@ type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
         yield _(generateSourceCode(script, scriptRanges.exportDefault.expression.end, script.content.length));
     }
     function* generateScriptContentAfterExportDefault() {
-        if (!script)
+        if (!script) {
             return;
-        if (!!scriptSetup && scriptRanges?.exportDefault)
+        }
+        if (!!scriptSetup && scriptRanges?.exportDefault) {
             yield _(generateSourceCode(script, scriptRanges.exportDefault.expression.end, script.content.length));
+        }
     }
     function* generateScriptSetupImports() {
-        if (!scriptSetup || !scriptSetupRanges)
+        if (!scriptSetup || !scriptSetupRanges) {
             return;
+        }
         yield _([
             scriptSetup.content.substring(0, Math.max(scriptSetupRanges.importSectionEndOffset, scriptSetupRanges.leadingCommentEndOffset)) + '\n',
             'scriptSetup',
@@ -381,8 +399,9 @@ type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
         if (scriptSetupRanges.defineProp.length) {
             yield _(` & ReturnType<typeof import('${vueCompilerOptions.lib}').defineEmits<{\n`);
             for (const defineProp of scriptSetupRanges.defineProp) {
-                if (!defineProp.isModel)
+                if (!defineProp.isModel) {
                     continue;
+                }
                 let propName = 'modelValue';
                 if (defineProp.name) {
                     propName = scriptSetup.content.substring(defineProp.name.start, defineProp.name.end);
@@ -402,8 +421,9 @@ type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
         yield _(`;\n`);
     }
     function* generateScriptSetupAndTemplate() {
-        if (!scriptSetup || !scriptSetupRanges)
+        if (!scriptSetup || !scriptSetupRanges) {
             return;
+        }
         const definePropMirrors = new Map();
         if (scriptSetup.generic) {
             if (!scriptRanges?.exportDefault) {
@@ -543,8 +563,9 @@ type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
         }
     }
     function* generateSetupFunction(functional, mode, definePropMirrors) {
-        if (!scriptSetupRanges || !scriptSetup)
+        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) {
@@ -699,8 +720,9 @@ type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
         }
     }
     function* generateComponent(functional) {
-        if (!scriptSetupRanges)
+        if (!scriptSetupRanges) {
             return;
+        }
         if (script && scriptRanges?.exportDefault && scriptRanges.exportDefault.expression.start !== scriptRanges.exportDefault.args.start) {
             // use defineComponent() from user space code if it exist
             yield _(generateSourceCode(script, scriptRanges.exportDefault.expression.start, scriptRanges.exportDefault.args.start));
@@ -772,12 +794,14 @@ type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
                 }
                 yield _(`},\n`);
             }
-            yield _(`emits: ({} as __VLS_NormalizeEmits<typeof __VLS_modelEmitsType`);
-            if (ranges.emits.define) {
-                yield _(` & typeof `);
-                yield _(ranges.emits.name ?? '__VLS_emit');
+            if (ranges.defineProp.filter(p => p.isModel).length || ranges.emits.define) {
+                yield _(`emits: ({} as __VLS_NormalizeEmits<typeof __VLS_modelEmitsType`);
+                if (ranges.emits.define) {
+                    yield _(` & typeof `);
+                    yield _(ranges.emits.name ?? '__VLS_emit');
+                }
+                yield _(`>),\n`);
             }
-            yield _(`>),\n`);
         }
         if (script && scriptRanges?.exportDefault?.args) {
             yield _(generateSourceCode(script, scriptRanges.exportDefault.args.start + 1, scriptRanges.exportDefault.args.end - 1));

package/lib/generators/template.js

@@ -243,11 +243,13 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
     function* generatePreResolveComponents() {
         yield _ts(`let __VLS_resolvedLocalAndGlobalComponents!: {}\n`);
         for (const [tagName] of tagOffsetsMap) {
-            if (nativeTags.has(tagName))
+            if (nativeTags.has(tagName)) {
                 continue;
+            }
             const isNamespacedTag = tagName.indexOf('.') >= 0;
-            if (isNamespacedTag)
+            if (isNamespacedTag) {
                 continue;
+            }
             yield _ts(`& __VLS_WithComponent<'${getCanonicalComponentName(tagName)}', typeof __VLS_localComponents, `);
             // order is important: https://github.com/vuejs/language-tools/issues/2010
             yield _ts(`"${(0, shared_1.capitalize)((0, shared_1.camelize)(tagName))}", `);
@@ -385,12 +387,15 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         let originalBlockConditionsLength = blockConditions.length;
         for (let i = 0; i < node.branches.length; i++) {
             const branch = node.branches[i];
-            if (i === 0)
+            if (i === 0) {
                 yield _ts('if');
-            else if (branch.condition)
+            }
+            else if (branch.condition) {
                 yield _ts('else if');
-            else
+            }
+            else {
                 yield _ts('else');
+            }
             let addedBlockCondition = false;
             if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
                 yield _ts(` `);
@@ -424,8 +429,9 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         if (leftExpressionRange && leftExpressionText) {
             const collectAst = createTsAst(node.parseResult, `const [${leftExpressionText}]`);
             (0, transform_1.collectVars)(ts, collectAst, collectAst, forBlockVars);
-            for (const varName of forBlockVars)
+            for (const varName of forBlockVars) {
                 localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
+            }
             yield _ts([leftExpressionText, 'template', leftExpressionRange.start, presetInfos.all]);
             yield* generateTsFormat(leftExpressionText, leftExpressionRange.start, formatBrackets.normal);
         }
@@ -445,8 +451,9 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             yield _ts('}\n');
             yield* generateTsFormat(source.content, source.loc.start.offset, formatBrackets.normal);
         }
-        for (const varName of forBlockVars)
+        for (const varName of forBlockVars) {
             localVars.set(varName, localVars.get(varName) - 1);
+        }
     }
     function* generateElement(node, parentEl, componentCtxVar) {
         yield _ts(`{\n`);
@@ -942,7 +949,10 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                     else {
                         const propVariableName = (0, shared_1.camelize)(prop.exp.loc.source);
                         if (validTsVarReg.test(propVariableName)) {
-                            yield _ts('__VLS_ctx.');
+                            if (!localVars.has(propVariableName)) {
+                                accessedGlobalVariables.add(propVariableName);
+                                yield _ts('__VLS_ctx.');
+                            }
                             yield* generateCamelized(prop.exp.loc.source, prop.exp.loc.start.offset, caps_all);
                             if (mode === 'normal') {
                                 yield _ts([
@@ -951,18 +961,17 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                                     prop.exp.loc.end.offset,
                                     (0, utils_1.disableAllFeatures)({
                                         __hint: {
-                                            setting: 'vue.inlayHints.vbindShorthand',
+                                            setting: 'vue.inlayHints.vBindShorthand',
                                             label: `="${propVariableName}"`,
                                             tooltip: [
                                                 `This is a shorthand for \`${prop.exp.loc.source}="${propVariableName}"\`.`,
-                                                'To hide this hint, set `vue.inlayHints.vbindShorthand` to `false` in IDE settings.',
+                                                'To hide this hint, set `vue.inlayHints.vBindShorthand` to `false` in IDE settings.',
                                                 '[More info](https://github.com/vuejs/core/pull/9451)',
                                             ].join('\n\n'),
                                         },
                                     })
                                 ]);
                             }
-                            accessedGlobalVariables.add(propVariableName);
                         }
                     }
                 }
@@ -983,8 +992,9 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                     || (prop.name === 'style' && ++styleAttrNum >= 2)
                     || (prop.name === 'class' && ++classAttrNum >= 2)
                     || (prop.name === 'name' && node.tag === 'slot') // #2308
-                )
+                ) {
                     continue;
+                }
                 if (vueCompilerOptions.target < 3
                     && (node.tag === 'transition' || node.tag === 'Transition')
                     && prop.name === 'persisted') {
@@ -1262,8 +1272,9 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         }
     }
     function* generateExtraAutoImport() {
-        if (!tempVars.length)
+        if (!tempVars.length) {
             return;
+        }
         yield _ts('// @ts-ignore\n'); // #2304
         yield _ts('[');
         for (const _vars of tempVars) {

package/lib/plugins/file-vue.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const parseSfc_1 = require("../utils/parseSfc");
-const plugin = (_ctx) => {
+const plugin = _ctx => {
     return {
         version: 2,
         parseSFC(_fileName, content) {

package/lib/plugins/vue-tsx.js

@@ -9,7 +9,7 @@ const utils_1 = require("../generators/utils");
 const scriptRanges_1 = require("../parsers/scriptRanges");
 const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
 exports.tsCodegen = new WeakMap();
-const plugin = (ctx) => {
+const plugin = ctx => {
     return {
         version: 2,
         requiredCompilerOptions: [
@@ -126,8 +126,9 @@ function createTsx(fileName, _sfc, ctx) {
         return classes;
     });
     const generatedTemplate = (0, computeds_1.computed)(() => {
-        if (!_sfc.template)
+        if (!_sfc.template) {
             return;
+        }
         const tsCodes = [];
         const tsFormatCodes = [];
         const inlineCssCodes = [];

package/lib/plugins.js

@@ -27,7 +27,9 @@ function getDefaultVueLanguagePlugins(pluginContext) {
     const pluginInstances = plugins
         .map(plugin => {
         try {
-            return plugin(pluginContext);
+            const instance = plugin(pluginContext);
+            instance.name ??= plugin.__moduleName;
+            return instance;
         }
         catch (err) {
             console.warn('[Vue] Failed to create plugin', err);
@@ -39,10 +41,10 @@ function getDefaultVueLanguagePlugins(pluginContext) {
         const bOrder = b.order ?? 0;
         return aOrder - bOrder;
     });
-    return pluginInstances.filter((plugin) => {
+    return pluginInstances.filter(plugin => {
         const valid = plugin.version === types_1.pluginVersion;
         if (!valid) {
-            console.warn(`[Vue] Plugin ${JSON.stringify(plugin.name)} API version incompatible, expected ${JSON.stringify(types_1.pluginVersion)} but got ${JSON.stringify(plugin.version)}`);
+            console.warn(`[Vue] Plugin ${JSON.stringify(plugin.name)} API version incompatible, expected "${types_1.pluginVersion}" but got "${plugin.version}".`);
         }
         return valid;
     });

package/lib/utils/transform.js

@@ -103,8 +103,9 @@ function walkIdentifiers(ts, node, ast, cb, localVars, blockVars = [], isRoot =
         for (const varName of blockVars) {
             localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
         }
-        if (node.initializer)
+        if (node.initializer) {
             walkIdentifiers(ts, node.initializer, ast, cb, localVars, blockVars, false);
+        }
     }
     else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
         const functionArgs = [];
@@ -114,11 +115,13 @@ function walkIdentifiers(ts, node, ast, cb, localVars, blockVars = [], isRoot =
                 walkIdentifiers(ts, param.type, ast, cb, localVars, blockVars, false);
             }
         }
-        for (const varName of functionArgs)
+        for (const varName of functionArgs) {
             localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
+        }
         walkIdentifiers(ts, node.body, ast, cb, localVars, blockVars, false);
-        for (const varName of functionArgs)
+        for (const varName of functionArgs) {
             localVars.set(varName, localVars.get(varName) - 1);
+        }
     }
     else if (ts.isObjectLiteralExpression(node)) {
         for (const prop of node.properties) {

package/lib/utils/ts.d.ts

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

package/lib/utils/ts.js

@@ -15,7 +15,8 @@ function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, confi
         }
         catch (err) { }
     }
-    const parsed = ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName, undefined, (vueOptions.extensions ?? ['.vue']).map(extension => ({
+    const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
+    const parsed = ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName, undefined, resolvedVueOptions.extensions.map(extension => ({
         extension: extension.slice(1),
         isMixedContent: true,
         scriptKind: ts.ScriptKind.Deferred,
@@ -26,7 +27,7 @@ function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, confi
     parsed.options.outDir = undefined;
     return {
         ...parsed,
-        vueOptions,
+        vueOptions: resolvedVueOptions,
     };
 }
 exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
@@ -45,7 +46,8 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath) {
             }
             catch (err) { }
         }
-        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath, undefined, (vueOptions.extensions ?? ['.vue']).map(extension => ({
+        const resolvedVueOptions = resolveVueCompilerOptions(vueOptions);
+        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost.host, path.dirname(tsConfigPath), {}, tsConfigPath, undefined, resolvedVueOptions.extensions.map(extension => ({
             extension: extension.slice(1),
             isMixedContent: true,
             scriptKind: ts.ScriptKind.Deferred,
@@ -56,7 +58,7 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath) {
         parsed.options.outDir = undefined;
         return {
             ...parsed,
-            vueOptions,
+            vueOptions: resolvedVueOptions,
         };
     }
     catch (err) {
@@ -118,7 +120,9 @@ function getPartialVueCompilerOptions(ts, tsConfigSourceFile) {
             try {
                 const resolvedPath = resolvePath(pluginPath);
                 if (resolvedPath) {
-                    return require(resolvedPath);
+                    const plugin = require(resolvedPath);
+                    plugin.__moduleName = pluginPath;
+                    return plugin;
                 }
                 else {
                     console.warn('[Vue] Load plugin failed:', pluginPath);

package/lib/utils/vue2TemplateCompiler.js

@@ -9,7 +9,7 @@ const compile = (template, options = {}) => {
     }
     const onError = options.onError;
     const onWarn = options.onWarn;
-    options.onError = (error) => {
+    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
         ) {
@@ -57,7 +57,7 @@ const compile = (template, options = {}) => {
 };
 exports.compile = compile;
 function baseCompile(template, options = {}) {
-    const onError = options.onError || ((error) => { throw error; });
+    const onError = options.onError || (error => { throw error; });
     const isModuleMode = options.mode === 'module';
     const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
     if (!prefixIdentifiers && options.cacheHandlers) {

package/lib/virtualFile/computedMappings.d.ts

@@ -1,4 +1,4 @@
-import { Mapping } from '@volar/language-core';
+import { CodeMapping } from '@volar/language-core';
 import type * as ts from 'typescript';
-import type { Sfc, VueCodeInformation } from '../types';
-export declare function computedMappings(snapshot: () => ts.IScriptSnapshot, sfc: Sfc): () => Mapping<VueCodeInformation>[];
+import type { Sfc } from '../types';
+export declare function computedMappings(snapshot: () => ts.IScriptSnapshot, sfc: Sfc): () => CodeMapping[];

package/lib/virtualFile/computedMappings.js

@@ -18,9 +18,9 @@ function computedMappings(snapshot, sfc) {
                 (0, language_core_1.replaceSourceRange)(str, undefined, block.startTagEnd, block.endTagStart, '\n\n');
             }
         }
-        return str
+        const mappings = str
             .filter(s => typeof s !== 'string')
-            .map((m) => {
+            .map(m => {
             const text = m[0];
             const start = m[2];
             return {
@@ -30,6 +30,36 @@ function computedMappings(snapshot, sfc) {
                 data: m[3],
             };
         });
+        // fix folding range end position failed to mapping
+        for (const block of [
+            sfc.script,
+            sfc.scriptSetup,
+            sfc.template,
+            ...sfc.styles,
+            ...sfc.customBlocks,
+        ]) {
+            const offsets = [];
+            if (block) {
+                let content = block.content;
+                if (content.endsWith('\r\n')) {
+                    content = content.slice(0, -2);
+                }
+                else if (content.endsWith('\n')) {
+                    content = content.slice(0, -1);
+                }
+                const offset = content.lastIndexOf('\n') + 1;
+                offsets.push(block.startTagEnd + offset);
+            }
+            if (offsets.length) {
+                mappings.push({
+                    sourceOffsets: offsets,
+                    generatedOffsets: offsets,
+                    lengths: offsets.map(() => 0),
+                    data: (0, utils_1.disableAllFeatures)({ structure: true }),
+                });
+            }
+        }
+        return mappings;
     });
 }
 exports.computedMappings = computedMappings;

package/lib/virtualFile/vueFile.d.ts

@@ -14,12 +14,12 @@ export declare class VueGeneratedCode implements VirtualCode {
     _snapshot: Signal<ts.IScriptSnapshot>;
     getVueSfc: () => import("@vue/compiler-sfc").SFCParseResult | undefined;
     sfc: import("../types").Sfc;
-    getMappings: () => import("@volar/language-core").Mapping<import("../types").VueCodeInformation>[];
+    getMappings: () => import("@volar/language-core").CodeMapping[];
     getEmbeddedCodes: () => VirtualCode[];
     codegenStacks: Stack[];
     get embeddedCodes(): VirtualCode[];
     get snapshot(): ts.IScriptSnapshot;
-    get mappings(): import("@volar/language-core").Mapping<import("../types").VueCodeInformation>[];
+    get mappings(): import("@volar/language-core").CodeMapping[];
     constructor(fileName: string, languageId: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: ReturnType<VueLanguagePlugin>[], ts: typeof import('typescript'), codegenStack: boolean);
     update(newSnapshot: ts.IScriptSnapshot): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "2.0.5",
+	"version": "2.0.7",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/language-core": "~2.1.1",
+		"@volar/language-core": "~2.1.3",
 		"@vue/compiler-dom": "^3.4.0",
 		"@vue/shared": "^3.4.0",
 		"computeds": "^0.0.1",
@@ -34,5 +34,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "62b4fcb0d3f7153b5b2f5571af32f519117d8466"
+	"gitHead": "4a37e8f3ebcf31ecfd2ea627f7611d5990ec5df6"
 }