@volar/vscode 1.4.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Johnson Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/out/common.d.ts

@@ -0,0 +1,4 @@
+import * as vscode from 'vscode';
+export declare function quickPick<T extends {
+    [K: string]: vscode.QuickPickItem | undefined;
+}>(groups: T | T[], placeholder?: string): Promise<keyof T | undefined>;

package/out/common.js

@@ -0,0 +1,45 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quickPick = void 0;
+const vscode = require("vscode");
+function quickPick(groups, placeholder) {
+    return new Promise(resolve => {
+        const quickPick = vscode.window.createQuickPick();
+        const items = [];
+        for (const group of Array.isArray(groups) ? groups : [groups]) {
+            const groupItems = Object.values(group);
+            if (groupItems.length) {
+                if (items.length) {
+                    items.push({ label: '', kind: vscode.QuickPickItemKind.Separator });
+                }
+                for (const item of groupItems) {
+                    if (item) {
+                        items.push(item);
+                    }
+                }
+            }
+        }
+        quickPick.items = items;
+        quickPick.placeholder = placeholder;
+        quickPick.onDidChangeSelection(selection => {
+            if (selection[0]) {
+                for (const options of Array.isArray(groups) ? groups : [groups]) {
+                    for (let key in options) {
+                        const option = options[key];
+                        if (selection[0] === option) {
+                            resolve(key);
+                            quickPick.hide();
+                            break;
+                        }
+                    }
+                }
+            }
+        });
+        quickPick.onDidHide(() => {
+            quickPick.dispose();
+            resolve(undefined);
+        });
+        quickPick.show();
+    });
+}
+exports.quickPick = quickPick;
+//# sourceMappingURL=common.js.map

package/out/features/autoInsertion.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode';
+import type { BaseLanguageClient } from 'vscode-languageclient';
+export declare function activate(clients: BaseLanguageClient[], active: (document: vscode.TextDocument) => boolean): Promise<vscode.Disposable>;

package/out/features/autoInsertion.js

@@ -0,0 +1,100 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = void 0;
+const vscode = require("vscode");
+const language_server_1 = require("@volar/language-server");
+function activate(clients, active) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let isEnabled = false;
+        let timeout;
+        updateEnabledState();
+        const d1 = vscode.workspace.onDidChangeTextDocument(onDidChangeTextDocument, null);
+        const d2 = vscode.window.onDidChangeActiveTextEditor(updateEnabledState, null);
+        return vscode.Disposable.from(d1, d2);
+        function updateEnabledState() {
+            isEnabled = false;
+            let editor = vscode.window.activeTextEditor;
+            if (!editor) {
+                return;
+            }
+            let document = editor.document;
+            if (!active(document)) {
+                return;
+            }
+            isEnabled = true;
+        }
+        function onDidChangeTextDocument({ document, contentChanges, reason }) {
+            var _a;
+            if (!isEnabled || contentChanges.length === 0 || reason === vscode.TextDocumentChangeReason.Undo || reason === vscode.TextDocumentChangeReason.Redo) {
+                return;
+            }
+            const activeDocument = (_a = vscode.window.activeTextEditor) === null || _a === void 0 ? void 0 : _a.document;
+            if (document !== activeDocument) {
+                return;
+            }
+            const lastChange = contentChanges[contentChanges.length - 1];
+            doAutoInsert(document, lastChange, (document, position, lastChange, isCancel) => __awaiter(this, void 0, void 0, function* () {
+                for (const client of clients) {
+                    const params = Object.assign(Object.assign({}, client.code2ProtocolConverter.asTextDocumentPositionParams(document, position)), { options: {
+                            lastChange: Object.assign(Object.assign({}, lastChange), { range: client.code2ProtocolConverter.asRange(lastChange.range) }),
+                        } });
+                    if (isCancel())
+                        return;
+                    const result = yield client.sendRequest(language_server_1.AutoInsertRequest.type, params);
+                    if (result !== undefined && result !== null) {
+                        if (typeof result === 'string') {
+                            return result;
+                        }
+                        else {
+                            return client.protocol2CodeConverter.asTextEdit(result);
+                        }
+                    }
+                }
+            }));
+        }
+        function doAutoInsert(document, lastChange, provider) {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = undefined;
+            }
+            const version = document.version;
+            timeout = setTimeout(() => {
+                const rangeStart = lastChange.range.start;
+                const position = new vscode.Position(rangeStart.line, rangeStart.character + lastChange.text.length);
+                provider(document, position, lastChange, () => { var _a; return ((_a = vscode.window.activeTextEditor) === null || _a === void 0 ? void 0 : _a.document.version) !== version; }).then(text => {
+                    if (text && isEnabled) {
+                        const activeEditor = vscode.window.activeTextEditor;
+                        if (activeEditor) {
+                            const activeDocument = activeEditor.document;
+                            if (document === activeDocument && activeDocument.version === version) {
+                                if (typeof text === 'string') {
+                                    const selections = activeEditor.selections;
+                                    if (selections.length && selections.some(s => s.active.isEqual(position))) {
+                                        activeEditor.insertSnippet(new vscode.SnippetString(text), selections.map(s => s.active));
+                                    }
+                                    else {
+                                        activeEditor.insertSnippet(new vscode.SnippetString(text), position);
+                                    }
+                                }
+                                else {
+                                    activeEditor.insertSnippet(new vscode.SnippetString(text.newText), text.range);
+                                }
+                            }
+                        }
+                    }
+                });
+                timeout = undefined;
+            }, 100);
+        }
+    });
+}
+exports.activate = activate;
+//# sourceMappingURL=autoInsertion.js.map

package/out/features/fileReferences.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode';
+import { BaseLanguageClient } from 'vscode-languageclient';
+export declare function activate(cmd: string, client: BaseLanguageClient): Promise<vscode.Disposable>;

package/out/features/fileReferences.js

@@ -0,0 +1,50 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = void 0;
+const vscode = require("vscode");
+const nls = require("vscode-nls");
+const language_server_1 = require("@volar/language-server");
+const localize = nls.loadMessageBundle();
+function activate(cmd, client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return vscode.commands.registerCommand(cmd, (uri) => __awaiter(this, void 0, void 0, function* () {
+            // https://github.com/microsoft/vscode/blob/main/extensions/typescript-language-features/src/languageFeatures/fileReferences.ts
+            yield vscode.window.withProgress({
+                location: vscode.ProgressLocation.Window,
+                title: localize('progress.title', "Finding file references")
+            }, (_progress) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (!uri) {
+                    const editor = vscode.window.activeTextEditor;
+                    if (!editor)
+                        return;
+                    uri = editor.document.uri;
+                }
+                const response = yield client.sendRequest(language_server_1.FindFileReferenceRequest.type, { textDocument: { uri: uri.toString() } });
+                if (!response) {
+                    return;
+                }
+                const locations = response.map(loc => client.protocol2CodeConverter.asLocation(loc));
+                const config = vscode.workspace.getConfiguration('references');
+                const existingSetting = config.inspect('preferredLocation');
+                yield config.update('preferredLocation', 'view');
+                try {
+                    yield vscode.commands.executeCommand('editor.action.showReferences', uri, new vscode.Position(0, 0), locations);
+                }
+                finally {
+                    yield config.update('preferredLocation', (_a = existingSetting === null || existingSetting === void 0 ? void 0 : existingSetting.workspaceFolderValue) !== null && _a !== void 0 ? _a : existingSetting === null || existingSetting === void 0 ? void 0 : existingSetting.workspaceValue);
+                }
+            }));
+        }));
+    });
+}
+exports.activate = activate;
+//# sourceMappingURL=fileReferences.js.map

package/out/features/reloadProject.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode';
+import type { BaseLanguageClient } from 'vscode-languageclient';
+export declare function activate(cmd: string, clients: BaseLanguageClient[]): Promise<vscode.Disposable>;

package/out/features/reloadProject.js

@@ -0,0 +1,26 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = void 0;
+const vscode = require("vscode");
+const language_server_1 = require("@volar/language-server");
+function activate(cmd, clients) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return vscode.commands.registerCommand(cmd, () => {
+            if (vscode.window.activeTextEditor) {
+                for (const client of clients) {
+                    client.sendNotification(language_server_1.ReloadProjectNotification.type, client.code2ProtocolConverter.asTextDocumentIdentifier(vscode.window.activeTextEditor.document));
+                }
+            }
+        });
+    });
+}
+exports.activate = activate;
+//# sourceMappingURL=reloadProject.js.map

package/out/features/serverStatus.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode';
+import type { BaseLanguageClient } from 'vscode-languageclient';
+export declare function activate(cmd: string, clients: BaseLanguageClient[]): Promise<vscode.Disposable>;

package/out/features/serverStatus.js

@@ -0,0 +1,25 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = void 0;
+const vscode = require("vscode");
+const language_server_1 = require("@volar/language-server");
+function activate(cmd, clients) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return vscode.commands.registerCommand(cmd, () => __awaiter(this, void 0, void 0, function* () {
+            for (const client of clients) {
+                yield client.sendNotification(language_server_1.ReportStats.type);
+                client.outputChannel.show();
+            }
+        }));
+    });
+}
+exports.activate = activate;
+//# sourceMappingURL=serverStatus.js.map

package/out/features/serverSys.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode';
+import { BaseLanguageClient } from 'vscode-languageclient';
+export declare function activate(context: vscode.ExtensionContext, client: BaseLanguageClient, cdn: string | undefined): Promise<vscode.Disposable>;

package/out/features/serverSys.js

@@ -0,0 +1,61 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = void 0;
+const vscode = require("vscode");
+const vscode_languageclient_1 = require("vscode-languageclient");
+const language_server_1 = require("@volar/language-server");
+function activate(context, client, cdn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const subscriptions = [];
+        addHandle();
+        subscriptions.push(client.onDidChangeState(() => {
+            if (client.state === vscode_languageclient_1.State.Running) {
+                addHandle();
+            }
+        }));
+        if (cdn) {
+            console.log('skips:', context.globalState.keys().filter(key => key.startsWith(cdn)).length);
+        }
+        return vscode.Disposable.from(...subscriptions);
+        function addHandle() {
+            subscriptions.push(client.onRequest(language_server_1.FsReadFileRequest.type, (uri) => __awaiter(this, void 0, void 0, function* () {
+                if (cdn && uri.startsWith(cdn) && context.globalState.get(uri) === false) {
+                    return;
+                }
+                const uri2 = client.protocol2CodeConverter.asUri(uri);
+                try {
+                    return yield vscode.workspace.fs.readFile(uri2);
+                }
+                catch (err) {
+                    if (cdn && uri.startsWith(cdn)) {
+                        context.globalState.update(uri, false);
+                    }
+                }
+            })));
+            subscriptions.push(client.onRequest(language_server_1.FsReadDirectoryRequest.type, (uri) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    if (cdn && uri.startsWith(cdn)) {
+                        return [];
+                    }
+                    const uri2 = client.protocol2CodeConverter.asUri(uri);
+                    let data = yield vscode.workspace.fs.readDirectory(uri2);
+                    data = data.filter(([name]) => !name.startsWith('.'));
+                    return data;
+                }
+                catch (_a) {
+                    return [];
+                }
+            })));
+        }
+    });
+}
+exports.activate = activate;
+//# sourceMappingURL=serverSys.js.map

package/out/features/showReferences.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode';
+import { BaseLanguageClient } from 'vscode-languageclient';
+export declare function activate(client: BaseLanguageClient): Promise<vscode.Disposable>;

package/out/features/showReferences.js

@@ -0,0 +1,36 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = void 0;
+const vscode = require("vscode");
+const vscode_languageclient_1 = require("vscode-languageclient");
+const language_server_1 = require("@volar/language-server");
+function activate(client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const subscriptions = [];
+        addHandle();
+        subscriptions.push(client.onDidChangeState(() => {
+            if (client.state === vscode_languageclient_1.State.Running) {
+                addHandle();
+            }
+        }));
+        return vscode.Disposable.from(...subscriptions);
+        function addHandle() {
+            subscriptions.push(client.onNotification(language_server_1.ShowReferencesNotification.type, params => {
+                const uri = params.textDocument.uri;
+                const pos = params.position;
+                const refs = params.references;
+                vscode.commands.executeCommand('editor.action.showReferences', vscode.Uri.parse(uri), new vscode.Position(pos.line, pos.character), refs.map(ref => new vscode.Location(vscode.Uri.parse(ref.uri), new vscode.Range(ref.range.start.line, ref.range.start.character, ref.range.end.line, ref.range.end.character))));
+            }));
+        }
+    });
+}
+exports.activate = activate;
+//# sourceMappingURL=showReferences.js.map

package/out/features/showVirtualFiles.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode';
+import { BaseLanguageClient } from 'vscode-languageclient';
+export declare function activate(cmd: string, client: BaseLanguageClient): Promise<vscode.Disposable>;

package/out/features/showVirtualFiles.js

@@ -0,0 +1,204 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = void 0;
+const vscode = require("vscode");
+const vscode_languageclient_1 = require("vscode-languageclient");
+const language_server_1 = require("@volar/language-server");
+const source_map_1 = require("@volar/source-map");
+const scheme = 'volar-virtual-file';
+const mappingDecorationType = vscode.window.createTextEditorDecorationType({
+    borderWidth: '1px',
+    borderStyle: 'solid',
+    overviewRulerColor: 'blue',
+    overviewRulerLane: vscode.OverviewRulerLane.Right,
+    light: {
+        // this color will be used in light color themes
+        borderColor: 'darkblue'
+    },
+    dark: {
+        // this color will be used in dark color themes
+        borderColor: 'lightblue'
+    }
+});
+const mappingSelectionDecorationType = vscode.window.createTextEditorDecorationType({
+    cursor: 'crosshair',
+    light: {
+        backgroundColor: 'lightblue'
+    },
+    dark: {
+        backgroundColor: 'darkblue'
+    }
+});
+function activate(cmd, client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        class MappingDataHoverProvider {
+            provideHover(document, position, _token) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const maps = virtualUriToSourceMap.get(document.uri.toString());
+                    if (!maps)
+                        return;
+                    const data = [];
+                    for (const [sourceUri, _, map] of maps) {
+                        const source = map.toSourceOffset(document.offsetAt(position));
+                        if (source) {
+                            data.push({
+                                uri: sourceUri,
+                                mapping: source,
+                            });
+                        }
+                    }
+                    if (data.length === 0)
+                        return;
+                    return new vscode.Hover(data.map((data) => [
+                        data.uri,
+                        '',
+                        '',
+                        '```json',
+                        JSON.stringify(data.mapping, null, 2),
+                        '```',
+                    ].join('\n')));
+                });
+            }
+        }
+        const subscriptions = [];
+        subscriptions.push(vscode.languages.registerHoverProvider({ scheme }, new MappingDataHoverProvider()));
+        const sourceUriToVirtualUris = new Map();
+        const virtualUriToSourceEditor = new Map();
+        const virtualUriToSourceMap = new Map();
+        const docChangeEvent = new vscode.EventEmitter();
+        const virtualDocuments = new Map();
+        let updateVirtualDocument;
+        let updateDecorationsTimeout;
+        subscriptions.push(vscode.window.onDidChangeActiveTextEditor(updateDecorations));
+        subscriptions.push(vscode.window.onDidChangeTextEditorSelection(updateDecorations));
+        subscriptions.push(vscode.window.onDidChangeVisibleTextEditors(updateDecorations));
+        subscriptions.push(vscode.workspace.onDidChangeTextDocument(e => {
+            if (sourceUriToVirtualUris.has(e.document.uri.toString())) {
+                const virtualUris = sourceUriToVirtualUris.get(e.document.uri.toString());
+                clearTimeout(updateVirtualDocument);
+                updateVirtualDocument = setTimeout(() => {
+                    virtualUris === null || virtualUris === void 0 ? void 0 : virtualUris.forEach(uri => {
+                        docChangeEvent.fire(vscode.Uri.parse(uri));
+                    });
+                }, 100);
+            }
+        }));
+        subscriptions.push(vscode.workspace.registerTextDocumentContentProvider(scheme, {
+            onDidChange: docChangeEvent.event,
+            provideTextDocumentContent(uri) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const fileName = uri.with({ scheme: 'file' }).fsPath;
+                    const requestEditor = virtualUriToSourceEditor.get(uri.toString());
+                    if (requestEditor) {
+                        const virtual = yield client.sendRequest(language_server_1.GetVirtualFileRequest.type, { sourceFileUri: requestEditor.document.uri.toString(), virtualFileName: fileName });
+                        virtualUriToSourceMap.set(uri.toString(), []);
+                        Object.entries(virtual.mappings).forEach(([sourceUri, mappings]) => {
+                            var _a, _b;
+                            const sourceEditor = vscode.window.visibleTextEditors.find(editor => editor.document.uri.toString() === sourceUri);
+                            if (sourceEditor) {
+                                (_a = virtualUriToSourceMap.get(uri.toString())) === null || _a === void 0 ? void 0 : _a.push([
+                                    sourceEditor.document.uri.toString(),
+                                    sourceEditor.document.version,
+                                    new source_map_1.SourceMap(mappings),
+                                ]);
+                                if (!sourceUriToVirtualUris.has(sourceUri)) {
+                                    sourceUriToVirtualUris.set(sourceUri, new Set());
+                                }
+                                (_b = sourceUriToVirtualUris.get(sourceUri)) === null || _b === void 0 ? void 0 : _b.add(uri.toString());
+                            }
+                        });
+                        virtualDocuments.set(uri.toString(), vscode_languageclient_1.TextDocument.create('', '', 0, virtual.content));
+                        clearTimeout(updateDecorationsTimeout);
+                        updateDecorationsTimeout = setTimeout(updateDecorations, 100);
+                        return virtual.content;
+                    }
+                });
+            }
+        }));
+        subscriptions.push(vscode.commands.registerCommand(cmd, () => __awaiter(this, void 0, void 0, function* () {
+            const sourceEditor = vscode.window.activeTextEditor;
+            if (sourceEditor) {
+                const fileNames = yield client.sendRequest(language_server_1.GetVirtualFileNamesRequest.type, client.code2ProtocolConverter.asTextDocumentIdentifier(sourceEditor.document));
+                const uris = fileNames.map(fileName => vscode.Uri.file(fileName).with({ scheme }));
+                sourceUriToVirtualUris.set(sourceEditor.document.uri.toString(), new Set(uris.map(uri => uri.toString())));
+                for (const uri of uris) {
+                    virtualUriToSourceEditor.set(uri.toString(), sourceEditor);
+                    vscode.window.showTextDocument(uri, { viewColumn: vscode.ViewColumn.Two, preview: false });
+                }
+            }
+        })));
+        return vscode.Disposable.from(...subscriptions);
+        function updateDecorations() {
+            for (const [virtualUri, sources] of virtualUriToSourceMap) {
+                const virtualEditor = vscode.window.visibleTextEditors.find(editor => editor.document.uri.toString() === virtualUri);
+                let virtualRanges1 = [];
+                let virtualRanges2 = [];
+                if (virtualEditor) {
+                    for (const [sourceUri, sourceVersion, map] of sources) {
+                        const sourceEditor = vscode.window.visibleTextEditors.find(editor => editor.document.uri.toString() === sourceUri);
+                        if (sourceEditor && sourceEditor.document.version === sourceVersion) {
+                            const mappingDecorationRanges = map.mappings.map(mapping => new vscode.Range(sourceEditor.document.positionAt(mapping.sourceRange[0]), sourceEditor.document.positionAt(mapping.sourceRange[1])));
+                            sourceEditor.setDecorations(mappingDecorationType, mappingDecorationRanges);
+                            virtualRanges1 = virtualRanges1.concat(map.mappings.map(mapping => new vscode.Range(getGeneratedPosition(virtualUri, mapping.generatedRange[0]), getGeneratedPosition(virtualUri, mapping.generatedRange[1]))));
+                            /**
+                             * selection
+                             */
+                            if (vscode.window.activeTextEditor) {
+                                const selection = vscode.window.activeTextEditor.selection;
+                                const startOffset = vscode.window.activeTextEditor.document.offsetAt(selection.start);
+                                sourceEditor.setDecorations(mappingSelectionDecorationType, []);
+                                if (vscode.window.activeTextEditor === sourceEditor) {
+                                    const matchVirtualRanges = [...map.toGeneratedOffsets(startOffset)];
+                                    sourceEditor.setDecorations(mappingSelectionDecorationType, matchVirtualRanges.map(mapped => new vscode.Range(sourceEditor.document.positionAt(mapped[1].sourceRange[0]), sourceEditor.document.positionAt(mapped[1].sourceRange[1]))));
+                                    virtualRanges2 = virtualRanges2.concat(matchVirtualRanges.map(mapped => new vscode.Range(getGeneratedPosition(virtualUri, mapped[1].generatedRange[0]), getGeneratedPosition(virtualUri, mapped[1].generatedRange[1]))));
+                                    const mapped = matchVirtualRanges.sort((a, b) => a[1].generatedRange[0] - b[1].generatedRange[0])[0];
+                                    if (mapped) {
+                                        virtualEditor.revealRange(new vscode.Range(getGeneratedPosition(virtualUri, mapped[1].generatedRange[0]), getGeneratedPosition(virtualUri, mapped[1].generatedRange[1])));
+                                    }
+                                }
+                                else if (vscode.window.activeTextEditor === virtualEditor) {
+                                    const matchSourceRanges = [...map.toSourceOffsets(startOffset)];
+                                    sourceEditor.setDecorations(mappingSelectionDecorationType, matchSourceRanges.map(mapped => new vscode.Range(sourceEditor.document.positionAt(mapped[1].sourceRange[0]), sourceEditor.document.positionAt(mapped[1].sourceRange[1]))));
+                                    virtualRanges2 = virtualRanges2.concat(matchSourceRanges.map(mapped => new vscode.Range(getGeneratedPosition(virtualUri, mapped[1].generatedRange[0]), getGeneratedPosition(virtualUri, mapped[1].generatedRange[1]))));
+                                    const mapped = matchSourceRanges.sort((a, b) => a[1].sourceRange[0] - b[1].sourceRange[0])[0];
+                                    if (mapped) {
+                                        sourceEditor.revealRange(new vscode.Range(sourceEditor.document.positionAt(mapped[1].sourceRange[0]), sourceEditor.document.positionAt(mapped[1].sourceRange[1])));
+                                    }
+                                }
+                            }
+                            else {
+                                sourceEditor.setDecorations(mappingSelectionDecorationType, []);
+                            }
+                        }
+                    }
+                    virtualEditor.setDecorations(mappingDecorationType, virtualRanges1);
+                    virtualEditor.setDecorations(mappingSelectionDecorationType, virtualRanges2);
+                }
+                else {
+                    for (const [sourceUri] of sources) {
+                        const sourceEditor = vscode.window.visibleTextEditors.find(editor => editor.document.uri.toString() === sourceUri);
+                        if (sourceEditor) {
+                            sourceEditor.setDecorations(mappingDecorationType, []);
+                            sourceEditor.setDecorations(mappingSelectionDecorationType, []);
+                        }
+                    }
+                }
+            }
+        }
+        function getGeneratedPosition(virtualUri, offset) {
+            const document = virtualDocuments.get(virtualUri);
+            const position = document.positionAt(offset);
+            return new vscode.Position(position.line, position.character);
+        }
+    });
+}
+exports.activate = activate;
+//# sourceMappingURL=showVirtualFiles.js.map

package/out/features/tsVersion.d.ts

@@ -0,0 +1,8 @@
+import * as vscode from 'vscode';
+import { BaseLanguageClient } from 'vscode-languageclient';
+export declare function activate(cmd: string, context: vscode.ExtensionContext, client: BaseLanguageClient, shouldStatusBarShow: (document: vscode.TextDocument) => boolean, resolveStatusText: (text: string) => string, disableTakeOverMode: boolean, cdn?: string): Promise<vscode.Disposable>;
+export declare function getTsdk(context: vscode.ExtensionContext): {
+    tsdk: string;
+    version: any;
+    isWorkspacePath: boolean;
+};

package/out/features/tsVersion.js

@@ -0,0 +1,209 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTsdk = exports.activate = void 0;
+const path = require("typesafe-path");
+const vscode = require("vscode");
+const common_1 = require("../common");
+const defaultTsdkPath = 'node_modules/typescript/lib';
+function activate(cmd, context, client, shouldStatusBarShow, resolveStatusText, disableTakeOverMode, cdn = 'https://unpkg.com/') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const subscriptions = [];
+        const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right);
+        statusBar.command = cmd;
+        subscriptions.push({ dispose: () => statusBar.dispose() });
+        subscriptions.push(vscode.commands.registerCommand(cmd, onCommand));
+        vscode.workspace.onDidChangeConfiguration(onDidChangeConfiguration, undefined, subscriptions);
+        vscode.window.onDidChangeActiveTextEditor(updateStatusBar, undefined, subscriptions);
+        updateStatusBar();
+        return vscode.Disposable.from(...subscriptions);
+        function onCommand() {
+            var _a, _b, _c, _d;
+            return __awaiter(this, void 0, void 0, function* () {
+                const tsdk = getTsdk(context);
+                const configTsdkPath = getConfigTsdkPath();
+                const vscodeTsdk = getVScodeTsdk();
+                const select = yield (0, common_1.quickPick)([
+                    {
+                        useVSCodeTsdk: {
+                            label: (!tsdk.isWorkspacePath ? '• ' : '') + "Use VS Code's Version",
+                            description: vscodeTsdk.version,
+                            detail: vscodeTsdk.isWeb ? vscodeTsdk.path.replace('/node_modules/', cdn) : undefined,
+                        },
+                        useConfigWorkspaceTsdk: configTsdkPath && !vscodeTsdk.isWeb ? {
+                            label: (tsdk.isWorkspacePath ? '• ' : '') + 'Use Workspace Version',
+                            description: (_b = yield getTsVersion((_a = resolveWorkspaceTsdk(configTsdkPath)) !== null && _a !== void 0 ? _a : '/')) !== null && _b !== void 0 ? _b : 'Could not load the TypeScript version at this path',
+                            detail: configTsdkPath,
+                        } : undefined,
+                        useDefaultWorkspaceTsdk: configTsdkPath !== defaultTsdkPath && !vscodeTsdk.isWeb ? {
+                            label: (tsdk.isWorkspacePath ? '• ' : '') + 'Use Workspace Version',
+                            description: (_d = yield getTsVersion((_c = resolveWorkspaceTsdk(defaultTsdkPath)) !== null && _c !== void 0 ? _c : '/')) !== null && _d !== void 0 ? _d : 'Could not load the TypeScript version at this path',
+                            detail: defaultTsdkPath,
+                        } : undefined,
+                    },
+                    ...(disableTakeOverMode ? [] : [{
+                            takeover: {
+                                label: 'What is Takeover Mode?',
+                            },
+                        }])
+                ]);
+                if (select === undefined) {
+                    return; // cancel
+                }
+                if (select === 'takeover') {
+                    vscode.env.openExternal(vscode.Uri.parse('https://vuejs.org/guide/typescript/overview.html#volar-takeover-mode'));
+                    return;
+                }
+                if (select === 'useDefaultWorkspaceTsdk') {
+                    yield vscode.workspace.getConfiguration('typescript').update('tsdk', defaultTsdkPath);
+                }
+                const useWorkspaceTsdk = select === 'useConfigWorkspaceTsdk' || select === 'useDefaultWorkspaceTsdk';
+                if (useWorkspaceTsdk !== isUseWorkspaceTsdk(context)) {
+                    context.workspaceState.update('typescript.useWorkspaceTsdk', useWorkspaceTsdk);
+                    reloadServers();
+                }
+                updateStatusBar();
+            });
+        }
+        function onDidChangeConfiguration(e) {
+            if (e.affectsConfiguration('typescript.tsdk') && isUseWorkspaceTsdk(context)) {
+                reloadServers();
+            }
+        }
+        function updateStatusBar() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!vscode.window.activeTextEditor
+                    || !shouldStatusBarShow(vscode.window.activeTextEditor.document)) {
+                    statusBar.hide();
+                }
+                else {
+                    const tsVersion = getTsdk(context).version;
+                    statusBar.text = tsVersion !== null && tsVersion !== void 0 ? tsVersion : 'x.x.x';
+                    statusBar.text = resolveStatusText(statusBar.text);
+                    statusBar.show();
+                }
+            });
+        }
+        function reloadServers() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const tsPaths = getTsdk(context);
+                const newInitOptions = Object.assign(Object.assign({}, client.clientOptions.initializationOptions), { typescript: tsPaths });
+                client.clientOptions.initializationOptions = newInitOptions;
+                vscode.commands.executeCommand('volar.action.restartServer');
+            });
+        }
+    });
+}
+exports.activate = activate;
+function getTsdk(context) {
+    if (isUseWorkspaceTsdk(context)) {
+        const resolvedTsdk = resolveWorkspaceTsdk(getConfigTsdkPath() || defaultTsdkPath);
+        if (resolvedTsdk) {
+            return {
+                tsdk: resolvedTsdk,
+                version: getTsVersion(resolvedTsdk),
+                isWorkspacePath: true,
+            };
+        }
+    }
+    const tsdk = getVScodeTsdk();
+    return {
+        tsdk: tsdk.path,
+        version: tsdk.version,
+        isWorkspacePath: false,
+    };
+}
+exports.getTsdk = getTsdk;
+function resolveWorkspaceTsdk(tsdk) {
+    var _a;
+    if (path.isAbsolute(tsdk)) {
+        try {
+            if (require.resolve('./typescript.js', { paths: [tsdk] })) {
+                return tsdk;
+            }
+        }
+        catch (_b) { }
+    }
+    const workspaceFolderFsPaths = ((_a = vscode.workspace.workspaceFolders) !== null && _a !== void 0 ? _a : []).map(folder => folder.uri.fsPath);
+    for (const folder of workspaceFolderFsPaths) {
+        const _path = path.join(folder, tsdk);
+        try {
+            if (require.resolve('./typescript.js', { paths: [_path] })) {
+                return _path;
+            }
+        }
+        catch (_c) { }
+    }
+}
+function getVScodeTsdk() {
+    const nightly = vscode.extensions.getExtension('ms-vscode.vscode-typescript-next');
+    if (nightly) {
+        const path = nightly.extensionPath.toString() + '/node_modules/typescript/lib';
+        return {
+            path,
+            version: getTsVersion(path),
+            isWeb: false,
+        };
+    }
+    if (vscode.env.appRoot) {
+        const libPath = path.join(vscode.env.appRoot, 'extensions/node_modules/typescript/lib');
+        return {
+            path: libPath,
+            version: getTsVersion(libPath),
+            isWeb: false,
+        };
+    }
+    // web
+    const version = require('typescript/package.json').version;
+    return {
+        path: `/node_modules/typescript@${version}/lib`,
+        version,
+        isWeb: true,
+    };
+}
+function getConfigTsdkPath() {
+    return vscode.workspace.getConfiguration('typescript').get('tsdk');
+}
+function isUseWorkspaceTsdk(context) {
+    return context.workspaceState.get('typescript.useWorkspaceTsdk', false);
+}
+function getTsVersion(libPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const p = libPath.toString().split('/');
+        const p2 = p.slice(0, -1);
+        const modulePath = p2.join('/');
+        const filePath = modulePath + '/package.json';
+        const contents = yield readFile(filePath);
+        if (contents === undefined) {
+            return;
+        }
+        let desc = null;
+        try {
+            desc = JSON.parse(contents);
+        }
+        catch (err) {
+            return;
+        }
+        if (!desc || !desc.version) {
+            return;
+        }
+        return desc.version;
+    });
+}
+function readFile(path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const data = yield vscode.workspace.fs.readFile(vscode.Uri.file(path));
+            return new TextDecoder('utf8').decode(data);
+        }
+        catch (_a) { }
+    });
+}
+//# sourceMappingURL=tsVersion.js.map

package/out/features/tsconfig.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode';
+import { BaseLanguageClient } from 'vscode-languageclient';
+export declare function activate(cmd: string, client: BaseLanguageClient, shouldStatusBarShow: (document: vscode.TextDocument) => boolean): Promise<void>;

package/out/features/tsconfig.js

@@ -0,0 +1,53 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = void 0;
+const vscode = require("vscode");
+const language_server_1 = require("@volar/language-server");
+const path = require("typesafe-path");
+function activate(cmd, client, shouldStatusBarShow) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const subscriptions = [];
+        const statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right);
+        let currentTsconfigUri;
+        updateStatusBar();
+        vscode.window.onDidChangeActiveTextEditor(updateStatusBar, undefined, subscriptions);
+        subscriptions.push(vscode.commands.registerCommand(cmd, () => __awaiter(this, void 0, void 0, function* () {
+            if (currentTsconfigUri) {
+                const document = yield vscode.workspace.openTextDocument(currentTsconfigUri);
+                yield vscode.window.showTextDocument(document);
+            }
+        })));
+        subscriptions.push(...subscriptions);
+        function updateStatusBar() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!vscode.window.activeTextEditor
+                    || !shouldStatusBarShow(vscode.window.activeTextEditor.document)) {
+                    statusBar.hide();
+                }
+                else {
+                    const tsconfig = yield client.sendRequest(language_server_1.GetMatchTsConfigRequest.type, client.code2ProtocolConverter.asTextDocumentIdentifier(vscode.window.activeTextEditor.document));
+                    if (tsconfig === null || tsconfig === void 0 ? void 0 : tsconfig.uri) {
+                        currentTsconfigUri = vscode.Uri.parse(tsconfig.uri);
+                        statusBar.text = path.relative((vscode.workspace.rootPath || '/'), currentTsconfigUri.fsPath);
+                        statusBar.command = cmd;
+                    }
+                    else {
+                        statusBar.text = 'No tsconfig';
+                        statusBar.command = undefined;
+                    }
+                    statusBar.show();
+                }
+            });
+        }
+    });
+}
+exports.activate = activate;
+//# sourceMappingURL=tsconfig.js.map

package/out/features/writeVirtualFiles.d.ts

@@ -0,0 +1,3 @@
+import * as vscode from 'vscode';
+import type { BaseLanguageClient } from 'vscode-languageclient';
+export declare function activate(cmd: string, client: BaseLanguageClient): Promise<vscode.Disposable>;

package/out/features/writeVirtualFiles.js

@@ -0,0 +1,24 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = void 0;
+const vscode = require("vscode");
+const language_server_1 = require("@volar/language-server");
+function activate(cmd, client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return vscode.commands.registerCommand(cmd, () => {
+            if (vscode.window.activeTextEditor) {
+                client.sendNotification(language_server_1.WriteVirtualFilesNotification.type, client.code2ProtocolConverter.asTextDocumentIdentifier(vscode.window.activeTextEditor.document));
+            }
+        });
+    });
+}
+exports.activate = activate;
+//# sourceMappingURL=writeVirtualFiles.js.map

package/out/index.d.ts

@@ -0,0 +1,12 @@
+import * as vscode from 'vscode';
+export { activate as activateAutoInsertion } from './features/autoInsertion';
+export { activate as activateShowVirtualFiles } from './features/showVirtualFiles';
+export { activate as activateWriteVirtualFiles } from './features/writeVirtualFiles';
+export { activate as activateFindFileReferences } from './features/fileReferences';
+export { activate as activateReloadProjects } from './features/reloadProject';
+export { activate as activateServerStats } from './features/serverStatus';
+export { activate as activateTsConfigStatusItem } from './features/tsconfig';
+export { activate as activateShowReferences } from './features/showReferences';
+export { activate as activateServerSys } from './features/serverSys';
+export { activate as activateTsVersionStatusItem, getTsdk } from './features/tsVersion';
+export declare function takeOverModeActive(context: vscode.ExtensionContext): boolean;

package/out/index.js

@@ -0,0 +1,32 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeOverModeActive = exports.getTsdk = exports.activateTsVersionStatusItem = exports.activateServerSys = exports.activateShowReferences = exports.activateTsConfigStatusItem = exports.activateServerStats = exports.activateReloadProjects = exports.activateFindFileReferences = exports.activateWriteVirtualFiles = exports.activateShowVirtualFiles = exports.activateAutoInsertion = void 0;
+const vscode = require("vscode");
+var autoInsertion_1 = require("./features/autoInsertion");
+Object.defineProperty(exports, "activateAutoInsertion", { enumerable: true, get: function () { return autoInsertion_1.activate; } });
+var showVirtualFiles_1 = require("./features/showVirtualFiles");
+Object.defineProperty(exports, "activateShowVirtualFiles", { enumerable: true, get: function () { return showVirtualFiles_1.activate; } });
+var writeVirtualFiles_1 = require("./features/writeVirtualFiles");
+Object.defineProperty(exports, "activateWriteVirtualFiles", { enumerable: true, get: function () { return writeVirtualFiles_1.activate; } });
+var fileReferences_1 = require("./features/fileReferences");
+Object.defineProperty(exports, "activateFindFileReferences", { enumerable: true, get: function () { return fileReferences_1.activate; } });
+var reloadProject_1 = require("./features/reloadProject");
+Object.defineProperty(exports, "activateReloadProjects", { enumerable: true, get: function () { return reloadProject_1.activate; } });
+var serverStatus_1 = require("./features/serverStatus");
+Object.defineProperty(exports, "activateServerStats", { enumerable: true, get: function () { return serverStatus_1.activate; } });
+var tsconfig_1 = require("./features/tsconfig");
+Object.defineProperty(exports, "activateTsConfigStatusItem", { enumerable: true, get: function () { return tsconfig_1.activate; } });
+var showReferences_1 = require("./features/showReferences");
+Object.defineProperty(exports, "activateShowReferences", { enumerable: true, get: function () { return showReferences_1.activate; } });
+var serverSys_1 = require("./features/serverSys");
+Object.defineProperty(exports, "activateServerSys", { enumerable: true, get: function () { return serverSys_1.activate; } });
+var tsVersion_1 = require("./features/tsVersion");
+Object.defineProperty(exports, "activateTsVersionStatusItem", { enumerable: true, get: function () { return tsVersion_1.activate; } });
+Object.defineProperty(exports, "getTsdk", { enumerable: true, get: function () { return tsVersion_1.getTsdk; } });
+function takeOverModeActive(context) {
+    if (vscode.workspace.getConfiguration('volar').get('takeOverMode.extension') === context.extension.id) {
+        return !vscode.extensions.getExtension('vscode.typescript-language-features');
+    }
+    return false;
+}
+exports.takeOverModeActive = takeOverModeActive;
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,30 @@
+{
+	"name": "@volar/vscode",
+	"version": "1.4.0-alpha.0",
+	"main": "out/index.js",
+	"license": "MIT",
+	"files": [
+		"out/**/*.js",
+		"out/**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/volar.js.git",
+		"directory": "packages/vscode"
+	},
+	"dependencies": {
+		"@volar/language-server": "1.4.0-alpha.0",
+		"@volar/source-map": "1.4.0-alpha.0",
+		"typesafe-path": "^0.2.2",
+		"vscode-nls": "^5.2.0"
+	},
+	"devDependencies": {
+		"@types/vscode": "latest",
+		"vscode-languageclient": "latest"
+	},
+	"peerDependencies": {
+		"@types/vscode": "*",
+		"vscode-languageclient": "*"
+	},
+	"gitHead": "2607410cae341cf802b446062d446ad497be2057"
+}