Updates dockerfile

node_modules/@volar/language-server/lib/features/configurations.d.ts

@@ -0,0 +1,8 @@
+import * as vscode from 'vscode-languageserver';
+import { LanguageServerState } from '../types';
+export declare function register(server: LanguageServerState): {
+    get: <T>(section: string, scopeUri?: string) => Promise<T | undefined>;
+    onDidChange: (cb: vscode.NotificationHandler<vscode.DidChangeConfigurationParams>) => {
+        dispose(): void;
+    };
+};

node_modules/@volar/language-server/lib/features/configurations.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const vscode = require("vscode-languageserver");
+function register(server) {
+    const configurations = new Map();
+    const didChangeCallbacks = new Set();
+    server.onInitialized(() => {
+        server.connection.onDidChangeConfiguration(params => {
+            configurations.clear(); // TODO: clear only the configurations that changed
+            for (const cb of didChangeCallbacks) {
+                cb(params);
+            }
+        });
+        const didChangeConfiguration = server.initializeParams.capabilities.workspace?.didChangeConfiguration;
+        if (didChangeConfiguration?.dynamicRegistration) {
+            server.connection.client.register(vscode.DidChangeConfigurationNotification.type);
+        }
+    });
+    return {
+        get,
+        onDidChange,
+    };
+    function get(section, scopeUri) {
+        if (!server.initializeParams.capabilities.workspace?.configuration) {
+            return Promise.resolve(undefined);
+        }
+        const didChangeConfiguration = server.initializeParams.capabilities.workspace?.didChangeConfiguration;
+        if (!scopeUri && didChangeConfiguration) {
+            if (!configurations.has(section)) {
+                configurations.set(section, getConfigurationWorker(section, scopeUri));
+            }
+            return configurations.get(section);
+        }
+        return getConfigurationWorker(section, scopeUri);
+    }
+    function onDidChange(cb) {
+        didChangeCallbacks.add(cb);
+        return {
+            dispose() {
+                didChangeCallbacks.delete(cb);
+            },
+        };
+    }
+    async function getConfigurationWorker(section, scopeUri) {
+        return (await server.connection.workspace.getConfiguration({ scopeUri, section })) ?? undefined /* replace null to undefined */;
+    }
+}
+//# sourceMappingURL=configurations.js.map

node_modules/@volar/language-server/lib/features/editorFeatures.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageServerState } from '../types';
+export declare function register(server: LanguageServerState): void;

node_modules/@volar/language-server/lib/features/editorFeatures.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const language_service_1 = require("@volar/language-service");
+const vscode_uri_1 = require("vscode-uri");
+const protocol_1 = require("../../protocol");
+function register(server) {
+    server.onInitialize(() => {
+        const { project } = server;
+        const scriptVersions = (0, language_service_1.createUriMap)();
+        const scriptVersionSnapshots = new WeakSet();
+        server.connection.onRequest(protocol_1.GetMatchTsConfigRequest.type, async (params) => {
+            const uri = vscode_uri_1.URI.parse(params.uri);
+            const languageService = (await project.getLanguageService(uri));
+            const tsProject = languageService.context.project.typescript;
+            if (tsProject?.configFileName) {
+                const { configFileName, uriConverter } = tsProject;
+                return { uri: uriConverter.asUri(configFileName).toString() };
+            }
+        });
+        server.connection.onRequest(protocol_1.GetVirtualFileRequest.type, async (document) => {
+            const uri = vscode_uri_1.URI.parse(document.uri);
+            const languageService = (await project.getLanguageService(uri));
+            const documentUri = vscode_uri_1.URI.parse(document.uri);
+            const sourceScript = languageService.context.language.scripts.get(documentUri);
+            if (sourceScript?.generated) {
+                return prune(sourceScript.generated.root);
+            }
+            function prune(virtualCode) {
+                const uri = languageService.context.encodeEmbeddedDocumentUri(sourceScript.id, virtualCode.id);
+                let version = scriptVersions.get(uri) ?? 0;
+                if (!scriptVersionSnapshots.has(virtualCode.snapshot)) {
+                    version++;
+                    scriptVersions.set(uri, version);
+                    scriptVersionSnapshots.add(virtualCode.snapshot);
+                }
+                return {
+                    fileUri: sourceScript.id.toString(),
+                    virtualCodeId: virtualCode.id,
+                    languageId: virtualCode.languageId,
+                    embeddedCodes: virtualCode.embeddedCodes?.map(prune) || [],
+                    version,
+                    disabled: languageService.context.disabledEmbeddedDocumentUris.has(uri),
+                };
+            }
+        });
+        server.connection.onRequest(protocol_1.GetVirtualCodeRequest.type, async (params) => {
+            const uri = vscode_uri_1.URI.parse(params.fileUri);
+            const languageService = (await project.getLanguageService(uri));
+            const sourceScript = languageService.context.language.scripts.get(vscode_uri_1.URI.parse(params.fileUri));
+            const virtualCode = sourceScript?.generated?.embeddedCodes.get(params.virtualCodeId);
+            if (virtualCode) {
+                const mappings = {};
+                for (const [sourceScript, map] of languageService.context.language.maps.forEach(virtualCode)) {
+                    mappings[sourceScript.id.toString()] = map.mappings;
+                }
+                return {
+                    content: virtualCode.snapshot.getText(0, virtualCode.snapshot.getLength()),
+                    mappings,
+                };
+            }
+        });
+        server.connection.onNotification(protocol_1.WriteVirtualFilesNotification.type, async (params) => {
+            // webpack compatibility
+            const _require = eval('require');
+            const fs = _require('fs');
+            const uri = vscode_uri_1.URI.parse(params.uri);
+            const languageService = (await project.getLanguageService(uri));
+            const tsProject = languageService.context.project.typescript;
+            if (tsProject) {
+                const { languageServiceHost } = tsProject;
+                for (const fileName of languageServiceHost.getScriptFileNames()) {
+                    if (!fs.existsSync(fileName)) {
+                        // global virtual files
+                        const snapshot = languageServiceHost.getScriptSnapshot(fileName);
+                        if (snapshot) {
+                            fs.writeFile(fileName, snapshot.getText(0, snapshot.getLength()), () => { });
+                        }
+                    }
+                    else {
+                        const uri = tsProject.uriConverter.asUri(fileName);
+                        const sourceScript = languageService.context.language.scripts.get(uri);
+                        if (sourceScript?.generated) {
+                            const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+                            if (serviceScript) {
+                                const { snapshot } = serviceScript.code;
+                                fs.writeFile(fileName + serviceScript.extension, snapshot.getText(0, snapshot.getLength()), () => { });
+                            }
+                            if (sourceScript.generated.languagePlugin.typescript?.getExtraServiceScripts) {
+                                for (const extraServiceScript of sourceScript.generated.languagePlugin.typescript.getExtraServiceScripts(uri.toString(), sourceScript.generated.root)) {
+                                    const { snapshot } = extraServiceScript.code;
+                                    fs.writeFile(fileName, snapshot.getText(0, snapshot.getLength()), () => { });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        server.connection.onRequest(protocol_1.LoadedTSFilesMetaRequest.type, async () => {
+            const sourceFilesData = new Map();
+            for (const languageService of await project.getExistingLanguageServices()) {
+                const tsLanguageService = languageService.context.inject('typescript/languageService');
+                const program = tsLanguageService?.getProgram();
+                const tsProject = languageService.context.project.typescript;
+                if (program && tsProject) {
+                    const { languageServiceHost, configFileName } = tsProject;
+                    const projectName = configFileName ?? (languageServiceHost.getCurrentDirectory() + '(inferred)');
+                    const sourceFiles = program.getSourceFiles() ?? [];
+                    for (const sourceFile of sourceFiles) {
+                        if (!sourceFilesData.has(sourceFile)) {
+                            let nodes = 0;
+                            sourceFile.forEachChild(function walk(node) {
+                                nodes++;
+                                node.forEachChild(walk);
+                            });
+                            sourceFilesData.set(sourceFile, {
+                                projectNames: [],
+                                size: nodes * 128,
+                            });
+                        }
+                        sourceFilesData.get(sourceFile).projectNames.push(projectName);
+                    }
+                    ;
+                }
+            }
+            const result = {
+                inputs: {},
+                outputs: {},
+            };
+            for (const [sourceFile, fileData] of sourceFilesData) {
+                let key = fileData.projectNames.sort().join(', ');
+                if (fileData.projectNames.length >= 2) {
+                    key = `Shared in ${fileData.projectNames.length} projects (${key})`;
+                }
+                result.outputs[key] ??= {
+                    imports: [],
+                    exports: [],
+                    entryPoint: '',
+                    inputs: {},
+                    bytes: 0,
+                };
+                result.outputs[key].inputs[sourceFile.fileName] = { bytesInOutput: fileData.size };
+            }
+            return result;
+        });
+        server.connection.onNotification(protocol_1.UpdateVirtualCodeStateNotification.type, async (params) => {
+            const uri = vscode_uri_1.URI.parse(params.fileUri);
+            const languageService = await project.getLanguageService(uri);
+            const virtualFileUri = languageService.context.encodeEmbeddedDocumentUri(vscode_uri_1.URI.parse(params.fileUri), params.virtualCodeId);
+            if (params.disabled) {
+                languageService.context.disabledEmbeddedDocumentUris.set(virtualFileUri, true);
+            }
+            else {
+                languageService.context.disabledEmbeddedDocumentUris.delete(virtualFileUri);
+            }
+        });
+        server.connection.onNotification(protocol_1.UpdateServicePluginStateNotification.type, async (params) => {
+            const uri = vscode_uri_1.URI.parse(params.uri);
+            const languageService = await project.getLanguageService(uri);
+            const plugin = languageService.context.plugins[params.serviceId][1];
+            if (params.disabled) {
+                languageService.context.disabledServicePlugins.add(plugin);
+            }
+            else {
+                languageService.context.disabledServicePlugins.delete(plugin);
+            }
+        });
+        server.connection.onRequest(protocol_1.GetServicePluginsRequest.type, async (params) => {
+            const uri = vscode_uri_1.URI.parse(params.uri);
+            const languageService = await project.getLanguageService(uri);
+            const result = [];
+            for (let pluginIndex = 0; pluginIndex < languageService.context.plugins.length; pluginIndex++) {
+                const plugin = languageService.context.plugins[pluginIndex];
+                result.push({
+                    id: pluginIndex,
+                    name: plugin[0].name,
+                    disabled: languageService.context.disabledServicePlugins.has(plugin[1]),
+                    features: Object.keys(plugin[1]),
+                });
+            }
+            return result;
+        });
+    });
+}
+//# sourceMappingURL=editorFeatures.js.map

node_modules/@volar/language-server/lib/features/fileSystem.d.ts

@@ -0,0 +1,8 @@
+import { FileSystem } from '@volar/language-service';
+import { URI } from 'vscode-uri';
+export declare function register(documents: ReturnType<typeof import('./textDocuments').register>, fileWatcher: ReturnType<typeof import('./fileWatcher').register>): {
+    readFile(uri: URI): string | Thenable<string | undefined>;
+    stat(uri: URI): import("@volar/language-service").FileStat | Thenable<import("@volar/language-service").FileStat | undefined>;
+    readDirectory(uri: URI): import("@volar/language-service").ProviderResult<[string, import("@volar/language-service").FileType][]>;
+    install(scheme: string, provider: FileSystem): void;
+};

node_modules/@volar/language-server/lib/features/fileSystem.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const language_service_1 = require("@volar/language-service");
+const vscode = require("vscode-languageserver");
+const vscode_uri_1 = require("vscode-uri");
+function register(documents, fileWatcher) {
+    const providers = new Map();
+    const readFileCache = (0, language_service_1.createUriMap)();
+    const statCache = (0, language_service_1.createUriMap)();
+    const readDirectoryCache = (0, language_service_1.createUriMap)();
+    documents.onDidSave(({ document }) => {
+        const uri = vscode_uri_1.URI.parse(document.uri);
+        readFileCache.set(uri, document.getText());
+        statCache.delete(uri);
+    });
+    fileWatcher.onDidChangeWatchedFiles(({ changes }) => {
+        for (const change of changes) {
+            const changeUri = vscode_uri_1.URI.parse(change.uri);
+            const dir = vscode_uri_1.URI.parse(change.uri.substring(0, change.uri.lastIndexOf('/')));
+            if (change.type === vscode.FileChangeType.Deleted) {
+                readFileCache.set(changeUri, undefined);
+                statCache.set(changeUri, undefined);
+                readDirectoryCache.delete(dir);
+            }
+            else if (change.type === vscode.FileChangeType.Changed) {
+                readFileCache.delete(changeUri);
+                statCache.delete(changeUri);
+            }
+            else if (change.type === vscode.FileChangeType.Created) {
+                readFileCache.delete(changeUri);
+                statCache.delete(changeUri);
+                readDirectoryCache.delete(dir);
+            }
+        }
+    });
+    return {
+        readFile(uri) {
+            if (!readFileCache.has(uri)) {
+                readFileCache.set(uri, providers.get(uri.scheme)?.readFile(uri));
+            }
+            return readFileCache.get(uri);
+        },
+        stat(uri) {
+            if (!statCache.has(uri)) {
+                statCache.set(uri, providers.get(uri.scheme)?.stat(uri));
+            }
+            return statCache.get(uri);
+        },
+        readDirectory(uri) {
+            if (!readDirectoryCache.has(uri)) {
+                readDirectoryCache.set(uri, providers.get(uri.scheme)?.readDirectory(uri) ?? []);
+            }
+            return readDirectoryCache.get(uri);
+        },
+        install(scheme, provider) {
+            providers.set(scheme, provider);
+        },
+    };
+}
+//# sourceMappingURL=fileSystem.js.map

node_modules/@volar/language-server/lib/features/fileWatcher.d.ts

@@ -0,0 +1,9 @@
+import { Disposable } from '@volar/language-service';
+import * as vscode from 'vscode-languageserver';
+import { LanguageServerState } from '../types';
+export declare function register(server: LanguageServerState): {
+    watchFiles: (patterns: string[]) => Promise<Disposable>;
+    onDidChangeWatchedFiles: (cb: vscode.NotificationHandler<vscode.DidChangeWatchedFilesParams>) => {
+        dispose: () => void;
+    };
+};

node_modules/@volar/language-server/lib/features/fileWatcher.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const vscode = require("vscode-languageserver");
+function register(server) {
+    let watchFilesDisposableCounter = 0;
+    let watchFilesDisposable;
+    const didChangeWatchedFilesCallbacks = new Set();
+    return {
+        watchFiles,
+        onDidChangeWatchedFiles,
+    };
+    async function watchFiles(patterns) {
+        const disposables = [];
+        const didChangeWatchedFiles = server.initializeParams.capabilities.workspace?.didChangeWatchedFiles;
+        const fileOperations = server.initializeParams.capabilities.workspace?.fileOperations;
+        if (didChangeWatchedFiles) {
+            if (watchFilesDisposableCounter === 0) {
+                watchFilesDisposable = server.connection.onDidChangeWatchedFiles(e => {
+                    for (const cb of didChangeWatchedFilesCallbacks) {
+                        cb(e);
+                    }
+                });
+            }
+            watchFilesDisposableCounter++;
+            disposables.push({
+                dispose() {
+                    watchFilesDisposableCounter--;
+                    if (watchFilesDisposableCounter === 0) {
+                        watchFilesDisposable?.dispose();
+                    }
+                }
+            });
+        }
+        if (didChangeWatchedFiles?.dynamicRegistration) {
+            disposables.push(await server.connection.client.register(vscode.DidChangeWatchedFilesNotification.type, {
+                watchers: patterns.map(pattern => ({ globPattern: pattern })),
+            }));
+        }
+        if (fileOperations?.dynamicRegistration && fileOperations.willRename) {
+            disposables.push(await server.connection.client.register(vscode.WillRenameFilesRequest.type, {
+                filters: patterns.map(pattern => ({ pattern: { glob: pattern } })),
+            }));
+        }
+        return {
+            dispose() {
+                for (const disposable of disposables) {
+                    disposable.dispose();
+                }
+                disposables.length = 0;
+            },
+        };
+    }
+    function onDidChangeWatchedFiles(cb) {
+        didChangeWatchedFilesCallbacks.add(cb);
+        return {
+            dispose: () => {
+                didChangeWatchedFilesCallbacks.delete(cb);
+            },
+        };
+    }
+}
+//# sourceMappingURL=fileWatcher.js.map

node_modules/@volar/language-server/lib/features/languageFeatures.d.ts

@@ -0,0 +1,4 @@
+import type { LanguageServerState } from '../types.js';
+export declare function register(server: LanguageServerState, documents: ReturnType<typeof import('./textDocuments')['register']>, configurations: ReturnType<typeof import('./configurations')['register']>): {
+    requestRefresh: (clearDiagnostics: boolean) => Promise<void>;
+};

node_modules/@volar/language-server/lib/features/languageFeatures.js

@@ -0,0 +1,768 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const language_service_1 = require("@volar/language-service");
+const vscode = require("vscode-languageserver");
+const vscode_uri_1 = require("vscode-uri");
+const protocol_1 = require("../../protocol");
+const reportedCapabilities = new Set();
+function register(server, documents, configurations) {
+    // Diagnostics support
+    let refreshReq = 0;
+    let updateDiagnosticsBatchReq = 0;
+    const refreshHandlers = [];
+    server.onInitialize(serverCapabilities => {
+        let lastCompleteUri;
+        let lastCompleteLs;
+        let lastCodeLensLs;
+        let lastCodeActionLs;
+        let lastCallHierarchyLs;
+        let lastTypeHierarchyLs;
+        let lastDocumentLinkLs;
+        let lastInlayHintLs;
+        let languageServiceToId = new WeakMap();
+        let currentLanguageServiceId = 0;
+        const languageServiceById = new Map();
+        const { languageServicePlugins, project, initializeParams } = server;
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.selectionRangeProvider)) {
+            serverCapabilities.selectionRangeProvider = true;
+            server.connection.onSelectionRanges(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getSelectionRanges(uri, params.positions, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.foldingRangeProvider)) {
+            serverCapabilities.foldingRangeProvider = true;
+            server.connection.onFoldingRanges(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getFoldingRanges(uri, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.linkedEditingRangeProvider)) {
+            serverCapabilities.linkedEditingRangeProvider = true;
+            server.connection.languages.onLinkedEditingRange(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getLinkedEditingRanges(uri, params.position, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.colorProvider)) {
+            serverCapabilities.colorProvider = true;
+            server.connection.onDocumentColor(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getDocumentColors(uri, token);
+                });
+            });
+            server.connection.onColorPresentation(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getColorPresentations(uri, params.color, params.range, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.documentSymbolProvider)) {
+            serverCapabilities.documentSymbolProvider = true;
+            server.connection.onDocumentSymbol(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getDocumentSymbols(uri, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.documentFormattingProvider)) {
+            serverCapabilities.documentFormattingProvider = true;
+            serverCapabilities.documentRangeFormattingProvider = true;
+            server.connection.onDocumentFormatting(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getDocumentFormattingEdits(uri, params.options, undefined, undefined, token);
+                });
+            });
+            server.connection.onDocumentRangeFormatting(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getDocumentFormattingEdits(uri, params.options, params.range, undefined, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.referencesProvider)) {
+            serverCapabilities.referencesProvider = true;
+            server.connection.onReferences(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getReferences(uri, params.position, { includeDeclaration: true }, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.implementationProvider)) {
+            serverCapabilities.implementationProvider = true;
+            server.connection.onImplementation(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, async (languageService) => {
+                    const definitions = await languageService.getImplementations(uri, params.position, token);
+                    return handleDefinitions(initializeParams, 'implementation', definitions ?? []);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.declarationProvider)) {
+            serverCapabilities.declarationProvider = true;
+            server.connection.onDeclaration(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, async (languageService) => {
+                    const definitions = await languageService.getDeclaration(uri, params.position, token);
+                    return handleDefinitions(initializeParams, 'declaration', definitions ?? []);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.definitionProvider)) {
+            serverCapabilities.definitionProvider = true;
+            server.connection.onDefinition(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, async (languageService) => {
+                    const definitions = await languageService.getDefinition(uri, params.position, token);
+                    return handleDefinitions(initializeParams, 'definition', definitions ?? []);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.typeDefinitionProvider)) {
+            serverCapabilities.typeDefinitionProvider = true;
+            server.connection.onTypeDefinition(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, async (languageService) => {
+                    const definitions = await languageService.getTypeDefinition(uri, params.position, token);
+                    return handleDefinitions(initializeParams, 'typeDefinition', definitions ?? []);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.callHierarchyProvider)) {
+            serverCapabilities.callHierarchyProvider = true;
+            server.connection.languages.callHierarchy.onPrepare(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    lastCallHierarchyLs = languageService;
+                    return languageService.getCallHierarchyItems(uri, params.position, token);
+                }) ?? [];
+            });
+            server.connection.languages.callHierarchy.onIncomingCalls(async (params, token) => {
+                return await lastCallHierarchyLs?.getCallHierarchyIncomingCalls(params.item, token) ?? [];
+            });
+            server.connection.languages.callHierarchy.onOutgoingCalls(async (params, token) => {
+                return await lastCallHierarchyLs?.getCallHierarchyOutgoingCalls(params.item, token) ?? [];
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.typeHierarchyProvider)) {
+            serverCapabilities.typeHierarchyProvider = true;
+            server.connection.languages.typeHierarchy.onPrepare(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    lastTypeHierarchyLs = languageService;
+                    return languageService.getTypeHierarchyItems(uri, params.position, token);
+                }) ?? [];
+            });
+            server.connection.languages.typeHierarchy.onSupertypes(async (params, token) => {
+                return await lastTypeHierarchyLs?.getTypeHierarchySupertypes(params.item, token) ?? [];
+            });
+            server.connection.languages.typeHierarchy.onSubtypes(async (params, token) => {
+                return await lastTypeHierarchyLs?.getTypeHierarchySubtypes(params.item, token) ?? [];
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.hoverProvider)) {
+            serverCapabilities.hoverProvider = true;
+            server.connection.onHover(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getHover(uri, params.position, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.documentHighlightProvider)) {
+            serverCapabilities.documentHighlightProvider = true;
+            server.connection.onDocumentHighlight(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getDocumentHighlights(uri, params.position, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.workspaceSymbolProvider)) {
+            serverCapabilities.workspaceSymbolProvider = {};
+            server.connection.onWorkspaceSymbol(async (params, token) => {
+                let languageServices = await project.getExistingLanguageServices();
+                if (!languageServices.length) {
+                    for (const document of documents.all()) {
+                        await project.getLanguageService(vscode_uri_1.URI.parse(document.uri));
+                    }
+                    languageServices = await project.getExistingLanguageServices();
+                }
+                const symbols = [];
+                for (const languageService of languageServices) {
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                    let languageServiceId = languageServiceToId.get(languageService);
+                    if (languageServiceId === undefined) {
+                        languageServiceId = currentLanguageServiceId;
+                        languageServiceToId.set(languageService, languageServiceId);
+                        languageServiceById.set(languageServiceId, new WeakRef(languageService));
+                    }
+                    const languageServiceResult = await languageService.getWorkspaceSymbols(params.query, token);
+                    for (const symbol of languageServiceResult) {
+                        symbol.data = {
+                            languageServiceId,
+                            originalData: symbol.data,
+                        };
+                    }
+                    symbols.push(...await languageService.getWorkspaceSymbols(params.query, token));
+                }
+                return symbols;
+            });
+            if (languageServicePlugins.some(({ capabilities }) => capabilities.workspaceSymbolProvider?.resolveProvider)) {
+                serverCapabilities.workspaceSymbolProvider.resolveProvider = true;
+                server.connection.onWorkspaceSymbolResolve(async (symbol, token) => {
+                    const languageServiceId = symbol.data?.languageServiceId;
+                    const languageService = languageServiceById.get(languageServiceId)?.deref();
+                    if (!languageService) {
+                        return symbol;
+                    }
+                    symbol.data = symbol.data?.originalData;
+                    return await languageService.resolveWorkspaceSymbol?.(symbol, token);
+                });
+            }
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.renameProvider)) {
+            serverCapabilities.renameProvider = {};
+            server.connection.onRenameRequest(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getRenameEdits(uri, params.position, params.newName, token);
+                });
+            });
+            if (languageServicePlugins.some(({ capabilities }) => capabilities.renameProvider?.prepareProvider)) {
+                serverCapabilities.renameProvider.prepareProvider = true;
+                server.connection.onPrepareRename(async (params, token) => {
+                    const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                    return await worker(uri, token, async (languageService) => {
+                        const result = await languageService.getRenameRange(uri, params.position, token);
+                        if (result && 'message' in result) {
+                            return new vscode.ResponseError(0, result.message);
+                        }
+                        return result;
+                    });
+                });
+            }
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.documentLinkProvider)) {
+            serverCapabilities.documentLinkProvider = {};
+            server.connection.onDocumentLinks(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    lastDocumentLinkLs = languageService;
+                    return languageService.getDocumentLinks(uri, token);
+                });
+            });
+            if (languageServicePlugins.some(({ capabilities }) => capabilities.documentLinkProvider?.resolveProvider)) {
+                serverCapabilities.documentLinkProvider.resolveProvider = true;
+                server.connection.onDocumentLinkResolve(async (link, token) => {
+                    return await lastDocumentLinkLs?.resolveDocumentLink(link, token);
+                });
+            }
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.codeLensProvider)) {
+            serverCapabilities.codeLensProvider = {};
+            server.connection.onCodeLens(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    lastCodeLensLs = languageService;
+                    return languageService.getCodeLenses(uri, token);
+                });
+            });
+            if (languageServicePlugins.some(({ capabilities }) => capabilities.codeLensProvider?.resolveProvider)) {
+                serverCapabilities.codeLensProvider.resolveProvider = true;
+                server.connection.onCodeLensResolve(async (codeLens, token) => {
+                    return await lastCodeLensLs?.resolveCodeLens(codeLens, token) ?? codeLens;
+                });
+            }
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.inlayHintProvider)) {
+            serverCapabilities.inlayHintProvider = {};
+            server.connection.languages.inlayHint.on(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    lastInlayHintLs = languageService;
+                    return languageService.getInlayHints(uri, params.range, token);
+                });
+            });
+            if (languageServicePlugins.some(({ capabilities }) => capabilities.inlayHintProvider?.resolveProvider)) {
+                serverCapabilities.inlayHintProvider.resolveProvider = true;
+                server.connection.languages.inlayHint.resolve(async (hint, token) => {
+                    return await lastInlayHintLs?.resolveInlayHint(hint, token) ?? hint;
+                });
+            }
+            refreshHandlers.push(() => {
+                if (initializeParams.capabilities.workspace?.inlayHint?.refreshSupport) {
+                    server.connection.languages.inlayHint.refresh();
+                }
+                else {
+                    wranCapabilitiesNotSupported('workspace.inlayHint.refreshSupport');
+                }
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.signatureHelpProvider)) {
+            serverCapabilities.signatureHelpProvider = {
+                triggerCharacters: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.signatureHelpProvider?.triggerCharacters ?? []).flat())],
+                retriggerCharacters: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.signatureHelpProvider?.retriggerCharacters ?? []).flat())],
+            };
+            server.connection.onSignatureHelp(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getSignatureHelp(uri, params.position, params.context, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.completionProvider)) {
+            serverCapabilities.completionProvider = {
+                triggerCharacters: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.completionProvider?.triggerCharacters ?? []).flat())],
+            };
+            server.connection.onCompletion(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, async (languageService) => {
+                    lastCompleteUri = params.textDocument.uri;
+                    lastCompleteLs = languageService;
+                    const list = await languageService.getCompletionItems(uri, params.position, params.context, token);
+                    list.items = list.items.map(item => handleCompletionItem(initializeParams, item));
+                    return list;
+                });
+            });
+            if (languageServicePlugins.some(({ capabilities }) => capabilities.completionProvider?.resolveProvider)) {
+                serverCapabilities.completionProvider.resolveProvider = true;
+                server.connection.onCompletionResolve(async (item, token) => {
+                    if (lastCompleteUri && lastCompleteLs) {
+                        item = await lastCompleteLs.resolveCompletionItem(item, token);
+                        item = handleCompletionItem(initializeParams, item);
+                    }
+                    return item;
+                });
+            }
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.semanticTokensProvider)) {
+            serverCapabilities.semanticTokensProvider = {
+                range: true,
+                full: false, // TODO: enable it after testing
+                legend: {
+                    tokenTypes: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.semanticTokensProvider?.legend?.tokenTypes ?? []).flat())],
+                    tokenModifiers: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.semanticTokensProvider?.legend?.tokenModifiers ?? []).flat())],
+                },
+            };
+            server.connection.languages.semanticTokens.on(async (params, token, _, resultProgress) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, async (languageService) => {
+                    return await languageService?.getSemanticTokens(uri, undefined, serverCapabilities.semanticTokensProvider.legend, tokens => resultProgress?.report(tokens), token);
+                }) ?? { data: [] };
+            });
+            server.connection.languages.semanticTokens.onRange(async (params, token, _, resultProgress) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, async (languageService) => {
+                    return await languageService?.getSemanticTokens(uri, params.range, serverCapabilities.semanticTokensProvider.legend, tokens => resultProgress?.report(tokens), token);
+                }) ?? { data: [] };
+            });
+            refreshHandlers.push(() => {
+                if (initializeParams.capabilities.workspace?.semanticTokens?.refreshSupport) {
+                    server.connection.languages.semanticTokens.refresh();
+                }
+                else {
+                    wranCapabilitiesNotSupported('workspace.semanticTokens.refreshSupport');
+                }
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.codeActionProvider)) {
+            serverCapabilities.codeActionProvider = {
+                codeActionKinds: languageServicePlugins.some(({ capabilities }) => capabilities.codeActionProvider?.codeActionKinds)
+                    ? [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.codeActionProvider?.codeActionKinds ?? []).flat())]
+                    : undefined,
+            };
+            server.connection.onCodeAction(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, async (languageService) => {
+                    lastCodeActionLs = languageService;
+                    let codeActions = await languageService.getCodeActions(uri, params.range, params.context, token) ?? [];
+                    for (const codeAction of codeActions) {
+                        if (codeAction.data && typeof codeAction.data === 'object') {
+                            codeAction.data.uri = params.textDocument.uri;
+                        }
+                        else {
+                            codeAction.data = { uri: params.textDocument.uri };
+                        }
+                    }
+                    if (!initializeParams.capabilities.textDocument?.codeAction?.disabledSupport
+                        && codeActions.some(codeAction => !codeAction.disabled)) {
+                        codeActions = codeActions.filter(codeAction => !codeAction.disabled);
+                        wranCapabilitiesNotSupported('textDocument.codeAction.disabledSupport');
+                    }
+                    return codeActions;
+                });
+            });
+            if (languageServicePlugins.some(({ capabilities }) => capabilities.codeActionProvider?.resolveProvider)) {
+                serverCapabilities.codeActionProvider.resolveProvider = true;
+                server.connection.onCodeActionResolve(async (codeAction, token) => {
+                    return await lastCodeActionLs?.resolveCodeAction(codeAction, token) ?? codeAction;
+                });
+            }
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.documentOnTypeFormattingProvider)) {
+            serverCapabilities.documentOnTypeFormattingProvider = {
+                firstTriggerCharacter: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.documentOnTypeFormattingProvider?.triggerCharacters ?? []).flat())][0],
+                moreTriggerCharacter: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.documentOnTypeFormattingProvider?.triggerCharacters ?? []).flat())].slice(1),
+            };
+            server.connection.onDocumentOnTypeFormatting(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getDocumentFormattingEdits(uri, params.options, undefined, params, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.executeCommandProvider)) {
+            serverCapabilities.executeCommandProvider = {
+                commands: [...new Set(languageServicePlugins.map(({ capabilities }) => capabilities.executeCommandProvider?.commands ?? []).flat())],
+            };
+            server.connection.onExecuteCommand(async (params, token) => {
+                let languageServices = await project.getExistingLanguageServices();
+                if (!languageServices.length) {
+                    for (const document of documents.all()) {
+                        await project.getLanguageService(vscode_uri_1.URI.parse(document.uri));
+                    }
+                    languageServices = await project.getExistingLanguageServices();
+                }
+                for (const languageService of languageServices) {
+                    if (languageService.executeCommand && languageService.commands.includes(params.command)) {
+                        try {
+                            return await languageService.executeCommand(params.command, params.arguments ?? [], token);
+                        }
+                        catch { }
+                    }
+                }
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.monikerProvider)) {
+            serverCapabilities.monikerProvider = true;
+            server.connection.languages.moniker.on(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getMoniker(uri, params.position, token);
+                }) ?? null;
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.inlineValueProvider)) {
+            serverCapabilities.inlineValueProvider = true;
+            server.connection.languages.inlineValue.on(async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getInlineValue(uri, params.range, params.context, token);
+                });
+            });
+            refreshHandlers.push(() => {
+                if (initializeParams.capabilities.workspace?.inlineValue?.refreshSupport) {
+                    server.connection.languages.inlineValue.refresh();
+                }
+                else {
+                    wranCapabilitiesNotSupported('workspace.inlineValue.refreshSupport');
+                }
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.autoInsertionProvider)) {
+            const triggerCharacterToConfigurationSections = new Map();
+            const tryAdd = (char, section) => {
+                let sectionSet = triggerCharacterToConfigurationSections.get(char);
+                if (!sectionSet) {
+                    triggerCharacterToConfigurationSections.set(char, sectionSet = new Set());
+                }
+                if (section) {
+                    sectionSet.add(section);
+                }
+            };
+            for (const { capabilities } of languageServicePlugins) {
+                if (capabilities.autoInsertionProvider) {
+                    const { triggerCharacters, configurationSections } = capabilities.autoInsertionProvider;
+                    if (configurationSections) {
+                        if (configurationSections.length !== triggerCharacters.length) {
+                            throw new Error('configurationSections.length !== triggerCharacters.length');
+                        }
+                        for (let i = 0; i < configurationSections.length; i++) {
+                            tryAdd(triggerCharacters[i], configurationSections[i]);
+                        }
+                    }
+                    else {
+                        for (const char of triggerCharacters) {
+                            tryAdd(char);
+                        }
+                    }
+                }
+            }
+            serverCapabilities.experimental ??= {};
+            serverCapabilities.experimental.autoInsertionProvider = {
+                triggerCharacters: [],
+                configurationSections: [],
+            };
+            for (const [char, sections] of triggerCharacterToConfigurationSections) {
+                if (sections.size) {
+                    serverCapabilities.experimental.autoInsertionProvider.triggerCharacters.push(char);
+                    serverCapabilities.experimental.autoInsertionProvider.configurationSections.push([...sections]);
+                }
+                else {
+                    serverCapabilities.experimental.autoInsertionProvider.triggerCharacters.push(char);
+                    serverCapabilities.experimental.autoInsertionProvider.configurationSections.push(null);
+                }
+            }
+            server.connection.onRequest(protocol_1.AutoInsertRequest.type, async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getAutoInsertSnippet(uri, params.selection, params.change, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.fileRenameEditsProvider)) {
+            serverCapabilities.experimental ??= {};
+            serverCapabilities.experimental.fileRenameEditsProvider = true;
+            server.connection.workspace.onWillRenameFiles(async (params, token) => {
+                const _edits = await Promise.all(params.files.map(async (file) => {
+                    const oldUri = vscode_uri_1.URI.parse(file.oldUri);
+                    const newUri = vscode_uri_1.URI.parse(file.newUri);
+                    return await worker(oldUri, token, languageService => {
+                        return languageService.getFileRenameEdits(oldUri, newUri, token) ?? null;
+                    }) ?? null;
+                }));
+                const edits = _edits.filter((edit) => !!edit);
+                if (edits.length) {
+                    (0, language_service_1.mergeWorkspaceEdits)(edits[0], ...edits.slice(1));
+                    return edits[0];
+                }
+                return null;
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.fileReferencesProvider)) {
+            serverCapabilities.experimental ??= {};
+            serverCapabilities.experimental.fileReferencesProvider = true;
+            server.connection.onRequest(protocol_1.FindFileReferenceRequest.type, async (params, token) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                return await worker(uri, token, languageService => {
+                    return languageService.getFileReferences(uri, token);
+                });
+            });
+        }
+        if (languageServicePlugins.some(({ capabilities }) => capabilities.documentDropEditsProvider)) {
+            serverCapabilities.experimental ??= {};
+            serverCapabilities.experimental.documentDropEditsProvider = true;
+            server.connection.onRequest(protocol_1.DocumentDropRequest.type, async ({ textDocument, position, dataTransfer }, token) => {
+                const dataTransferMap = new Map();
+                for (const item of dataTransfer) {
+                    dataTransferMap.set(item.mimeType, {
+                        value: item.value,
+                        asString() {
+                            return server.connection.sendRequest(protocol_1.DocumentDrop_DataTransferItemAsStringRequest.type, { mimeType: item.mimeType });
+                        },
+                        asFile() {
+                            if (item.file) {
+                                return {
+                                    name: item.file.name,
+                                    uri: item.file.uri,
+                                    data() {
+                                        return server.connection.sendRequest(protocol_1.DocumentDrop_DataTransferItemFileDataRequest.type, { mimeType: item.mimeType });
+                                    },
+                                };
+                            }
+                        },
+                    });
+                }
+                const uri = vscode_uri_1.URI.parse(textDocument.uri);
+                const languageService = (await project.getLanguageService(uri));
+                return languageService.getDocumentDropEdits(uri, position, dataTransferMap, token);
+            });
+        }
+        // Diagnostic support
+        const supportsDiagnosticPull = !!initializeParams.capabilities.workspace?.diagnostics;
+        const diagnosticProvider = languageServicePlugins.some(({ capabilities }) => !!capabilities.diagnosticProvider);
+        const interFileDependencies = languageServicePlugins.some(({ capabilities }) => capabilities.diagnosticProvider?.interFileDependencies);
+        const workspaceDiagnostics = languageServicePlugins.some(({ capabilities }) => capabilities.diagnosticProvider?.workspaceDiagnostics);
+        if (diagnosticProvider) {
+            if (supportsDiagnosticPull && !interFileDependencies) {
+                serverCapabilities.diagnosticProvider = {
+                    // Unreliable, see https://github.com/microsoft/vscode-languageserver-node/issues/848#issuecomment-2189521060
+                    interFileDependencies: false,
+                    workspaceDiagnostics,
+                };
+                refreshHandlers.push(() => {
+                    if (initializeParams.capabilities.workspace?.diagnostics?.refreshSupport) {
+                        server.connection.languages.diagnostics.refresh();
+                    }
+                    else {
+                        wranCapabilitiesNotSupported('workspace.diagnostics.refreshSupport');
+                    }
+                });
+            }
+            else {
+                documents.onDidChangeContent(({ document }) => {
+                    const changedDocument = documents.get(vscode_uri_1.URI.parse(document.uri));
+                    if (!changedDocument) {
+                        return;
+                    }
+                    if (interFileDependencies) {
+                        const remainingDocuments = [...documents.all()].filter(doc => doc !== changedDocument);
+                        updateDiagnosticsBatch(project, [changedDocument, ...remainingDocuments]);
+                    }
+                    else {
+                        updateDiagnosticsBatch(project, [changedDocument]);
+                    }
+                });
+                documents.onDidClose(({ document }) => {
+                    server.connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
+                });
+                configurations.onDidChange(() => requestRefresh(false));
+                refreshHandlers.push(async (clearDiagnostics) => {
+                    if (clearDiagnostics) {
+                        for (const document of documents.all()) {
+                            server.connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
+                        }
+                    }
+                    await updateDiagnosticsBatch(project, [...documents.all()]);
+                });
+            }
+            server.connection.languages.diagnostics.on(async (params, token, _workDoneProgressReporter, resultProgressReporter) => {
+                const uri = vscode_uri_1.URI.parse(params.textDocument.uri);
+                const result = await worker(uri, token, languageService => {
+                    return languageService.getDiagnostics(uri, errors => {
+                        // resultProgressReporter is undefined in vscode
+                        resultProgressReporter?.report({
+                            relatedDocuments: {
+                                [params.textDocument.uri]: {
+                                    kind: vscode.DocumentDiagnosticReportKind.Full,
+                                    items: errors,
+                                },
+                            },
+                        });
+                    }, token);
+                });
+                return {
+                    kind: vscode.DocumentDiagnosticReportKind.Full,
+                    items: result ?? [],
+                };
+            });
+        }
+        if (workspaceDiagnostics) {
+            server.connection.languages.diagnostics.onWorkspace(async (_params, token) => {
+                let languageServices = await project.getExistingLanguageServices();
+                if (!languageServices.length) {
+                    for (const document of documents.all()) {
+                        await project.getLanguageService(vscode_uri_1.URI.parse(document.uri));
+                    }
+                    languageServices = await project.getExistingLanguageServices();
+                }
+                const items = [];
+                for (const languageService of languageServices) {
+                    if (token.isCancellationRequested) {
+                        break;
+                    }
+                    const result = await languageService.getWorkspaceDiagnostics(token);
+                    items.push(...result);
+                }
+                return { items };
+            });
+        }
+    });
+    return { requestRefresh };
+    async function requestRefresh(clearDiagnostics) {
+        const req = ++refreshReq;
+        const delay = 250;
+        await sleep(delay);
+        if (req !== refreshReq) {
+            return;
+        }
+        for (const handler of refreshHandlers) {
+            handler(clearDiagnostics);
+        }
+    }
+    async function updateDiagnosticsBatch(project, documents) {
+        const req = ++updateDiagnosticsBatchReq;
+        const delay = 250;
+        const token = {
+            get isCancellationRequested() {
+                return req !== updateDiagnosticsBatchReq;
+            },
+            onCancellationRequested: vscode.Event.None,
+        };
+        for (const doc of documents) {
+            await sleep(delay);
+            if (token.isCancellationRequested) {
+                break;
+            }
+            await updateDiagnostics(project, vscode_uri_1.URI.parse(doc.uri), doc.version, token);
+        }
+    }
+    async function updateDiagnostics(project, uri, version, token) {
+        const languageService = await project.getLanguageService(uri);
+        const diagnostics = await languageService.getDiagnostics(uri, diagnostics => server.connection.sendDiagnostics({ uri: uri.toString(), diagnostics, version }), token);
+        if (!token.isCancellationRequested) {
+            server.connection.sendDiagnostics({ uri: uri.toString(), diagnostics, version });
+        }
+    }
+    function worker(uri, token, cb) {
+        return new Promise(resolve => {
+            server.env.timer.setImmediate(async () => {
+                if (token.isCancellationRequested) {
+                    resolve(undefined);
+                    return;
+                }
+                const languageService = (await server.project.getLanguageService((0, language_service_1.decodeEmbeddedDocumentUri)(uri)?.[0] ?? uri));
+                const result = await cb(languageService);
+                if (token.isCancellationRequested) {
+                    resolve(undefined);
+                    return;
+                }
+                resolve(result);
+            });
+        });
+    }
+    function handleCompletionItem(initializeParams, item) {
+        const snippetSupport = initializeParams.capabilities.textDocument?.completion?.completionItem?.snippetSupport ?? false;
+        const insertReplaceSupport = initializeParams.capabilities.textDocument?.completion?.completionItem?.insertReplaceSupport ?? false;
+        if (!snippetSupport && item.insertTextFormat === vscode.InsertTextFormat.Snippet) {
+            item.insertTextFormat = vscode.InsertTextFormat.PlainText;
+            if (item.insertText) {
+                item.insertText = item.insertText.replace(/\$\d+/g, '');
+                item.insertText = item.insertText.replace(/\${\d+:([^}]*)}/g, '');
+            }
+            wranCapabilitiesNotSupported('textDocument.completion.completionItem.snippetSupport');
+        }
+        if (!insertReplaceSupport && item.textEdit && vscode.InsertReplaceEdit.is(item.textEdit)) {
+            item.textEdit = vscode.TextEdit.replace(item.textEdit.insert, item.textEdit.newText);
+            wranCapabilitiesNotSupported('textDocument.completion.completionItem.insertReplaceSupport');
+        }
+        return item;
+    }
+    function handleDefinitions(initializeParams, type, items) {
+        const linkSupport = initializeParams.capabilities.textDocument?.[type]?.linkSupport ?? false;
+        if (!linkSupport) {
+            wranCapabilitiesNotSupported(`textDocument.${type}.linkSupport`);
+            return items.map(item => ({
+                uri: item.targetUri,
+                range: item.targetRange,
+            }));
+        }
+        return items;
+    }
+}
+function wranCapabilitiesNotSupported(path) {
+    if (reportedCapabilities.has(path)) {
+        return;
+    }
+    reportedCapabilities.add(path);
+    console.warn(`${path} is not supported by the client but could be used by the server.`);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=languageFeatures.js.map

node_modules/@volar/language-server/lib/features/textDocuments.d.ts

@@ -0,0 +1,12 @@
+import * as vscode from 'vscode-languageserver';
+import { URI } from 'vscode-uri';
+import { LanguageServerState } from '../types';
+import { SnapshotDocument } from '../utils/snapshotDocument';
+export declare function register(server: LanguageServerState): {
+    all: () => SnapshotDocument[];
+    onDidChangeContent: vscode.Event<vscode.TextDocumentChangeEvent<SnapshotDocument>>;
+    onDidOpen: vscode.Event<vscode.TextDocumentChangeEvent<SnapshotDocument>>;
+    onDidClose: vscode.Event<vscode.TextDocumentChangeEvent<SnapshotDocument>>;
+    onDidSave: vscode.Event<vscode.TextDocumentChangeEvent<SnapshotDocument>>;
+    get(uri: URI): SnapshotDocument | undefined;
+};

node_modules/@volar/language-server/lib/features/textDocuments.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const vscode = require("vscode-languageserver");
+const vscode_uri_1 = require("vscode-uri");
+const snapshotDocument_1 = require("../utils/snapshotDocument");
+function register(server) {
+    const syncedDocumentParsedUriToUri = new Map();
+    const documentsCache = new Map();
+    const documents = new vscode.TextDocuments({
+        create(uri, languageId, version, text) {
+            const cache = documentsCache.get(uri)?.deref();
+            if (cache && cache.languageId === languageId && cache.version === version && cache.getText() === text) {
+                return cache;
+            }
+            const document = new snapshotDocument_1.SnapshotDocument(uri, languageId, version, text);
+            documentsCache.set(uri, new WeakRef(document));
+            return document;
+        },
+        update(snapshot, contentChanges, version) {
+            snapshot.update(contentChanges, version);
+            return snapshot;
+        },
+    });
+    documents.listen(server.connection);
+    documents.onDidOpen(({ document }) => {
+        const parsedUri = vscode_uri_1.URI.parse(document.uri);
+        syncedDocumentParsedUriToUri.set(parsedUri.toString(), document.uri);
+    });
+    documents.onDidClose(({ document }) => {
+        const parsedUri = vscode_uri_1.URI.parse(document.uri);
+        syncedDocumentParsedUriToUri.delete(parsedUri.toString());
+    });
+    server.onInitialize(serverCapabilities => {
+        serverCapabilities.textDocumentSync = vscode.TextDocumentSyncKind.Incremental;
+    });
+    return {
+        all: documents.all.bind(documents),
+        onDidChangeContent: documents.onDidChangeContent.bind(documents),
+        onDidOpen: documents.onDidOpen.bind(documents),
+        onDidClose: documents.onDidClose.bind(documents),
+        onDidSave: documents.onDidSave.bind(documents),
+        get(uri) {
+            return documents.get(getSyncedDocumentKey(uri) ?? uri.toString());
+        },
+    };
+    function getSyncedDocumentKey(uri) {
+        const originalUri = syncedDocumentParsedUriToUri.get(uri.toString());
+        if (originalUri) {
+            return originalUri;
+        }
+    }
+}
+//# sourceMappingURL=textDocuments.js.map

node_modules/@volar/language-server/lib/features/workspaceFolders.d.ts

@@ -0,0 +1,10 @@
+import * as vscode from 'vscode-languageserver';
+import { URI } from 'vscode-uri';
+import { LanguageServerState } from '../types';
+export declare function register(server: LanguageServerState): {
+    readonly all: URI[];
+    has(uri: URI): boolean;
+    onDidChange: (cb: vscode.NotificationHandler<vscode.WorkspaceFoldersChangeEvent>) => {
+        dispose(): void;
+    };
+};

node_modules/@volar/language-server/lib/features/workspaceFolders.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const language_service_1 = require("@volar/language-service");
+const vscode_uri_1 = require("vscode-uri");
+function register(server) {
+    const folders = (0, language_service_1.createUriMap)();
+    const didChangeCallbacks = new Set();
+    server.onInitialize(serverCapabilities => {
+        const { initializeParams } = server;
+        if (initializeParams.workspaceFolders?.length) {
+            for (const folder of initializeParams.workspaceFolders) {
+                folders.set(vscode_uri_1.URI.parse(folder.uri), true);
+            }
+        }
+        else if (initializeParams.rootUri) {
+            folders.set(vscode_uri_1.URI.parse(initializeParams.rootUri), true);
+        }
+        else if (initializeParams.rootPath) {
+            folders.set(vscode_uri_1.URI.file(initializeParams.rootPath), true);
+        }
+        // #18
+        serverCapabilities.workspace ??= {};
+        serverCapabilities.workspace.workspaceFolders = {
+            supported: true,
+            changeNotifications: true,
+        };
+    });
+    server.onInitialized(() => {
+        if (server.initializeParams.capabilities.workspace?.workspaceFolders) {
+            server.connection.workspace.onDidChangeWorkspaceFolders(e => {
+                e.added = e.added.filter(folder => !folders.has(vscode_uri_1.URI.parse(folder.uri)));
+                e.removed = e.removed.filter(folder => folders.has(vscode_uri_1.URI.parse(folder.uri)));
+                if (e.added.length || e.removed.length) {
+                    for (const folder of e.added) {
+                        folders.set(vscode_uri_1.URI.parse(folder.uri), true);
+                    }
+                    for (const folder of e.removed) {
+                        folders.delete(vscode_uri_1.URI.parse(folder.uri));
+                    }
+                    server.project.reload();
+                    for (const cb of didChangeCallbacks) {
+                        cb(e);
+                    }
+                }
+            });
+        }
+    });
+    return {
+        get all() {
+            return [...folders.keys()];
+        },
+        has(uri) {
+            return folders.has(uri);
+        },
+        onDidChange,
+    };
+    function onDidChange(cb) {
+        didChangeCallbacks.add(cb);
+        return {
+            dispose() {
+                didChangeCallbacks.delete(cb);
+            },
+        };
+    }
+}
+//# sourceMappingURL=workspaceFolders.js.map