@volar/typescript 2.4.0-alpha.2 → 2.4.0-alpha.20

package/index.d.ts

@@ -18,8 +18,10 @@ declare module '@volar/language-service' {
             };
             languageServiceHost: ts.LanguageServiceHost;
             getExtraServiceScript(fileName: string): TypeScriptExtraServiceScript | undefined;
-            asUri(fileName: string): URI;
-            asFileName(uri: URI): string;
+            uriConverter: {
+                asUri(fileName: string): URI;
+                asFileName(uri: URI): string;
+            };
         };
     }
 }

package/lib/node/decorateLanguageServiceHost.js

@@ -28,7 +28,7 @@ function decorateLanguageServiceHost(ts, language, languageServiceHost) {
         };
     }
     if (pluginExtensions.length) {
-        const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, languageServiceHost, language.plugins, fileName => language.scripts.get(fileName));
+        const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, ts.sys.getFileSize, languageServiceHost, language.plugins, fileName => language.scripts.get(fileName));
         const getCanonicalFileName = languageServiceHost.useCaseSensitiveFileNames?.()
             ? (fileName) => fileName
             : (fileName) => fileName.toLowerCase();

package/lib/node/proxyCreateProgram.js

@@ -144,7 +144,7 @@ function proxyCreateProgram(ts, original, create) {
             };
             if (extensions.length) {
                 options.options.allowArbitraryExtensions = true;
-                const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, originalHost, language.plugins, fileName => language.scripts.get(fileName));
+                const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, ts.sys.getFileSize, originalHost, language.plugins, fileName => language.scripts.get(fileName));
                 const resolveModuleNameLiterals = originalHost.resolveModuleNameLiterals;
                 const resolveModuleNames = originalHost.resolveModuleNames;
                 options.host.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, compilerOptions, ...rest) => {

package/lib/node/proxyLanguageService.js

@@ -29,6 +29,7 @@ function createProxyLanguageService(languageService) {
                     case 'getDocumentHighlights': return getDocumentHighlights(language, target[p]);
                     case 'getApplicableRefactors': return getApplicableRefactors(language, target[p]);
                     case 'getEditsForRefactor': return getEditsForRefactor(language, target[p]);
+                    case 'getCombinedCodeFix': return getCombinedCodeFix(language, target[p]);
                     case 'getRenameInfo': return getRenameInfo(language, target[p]);
                     case 'getCodeFixesAtPosition': return getCodeFixesAtPosition(language, target[p]);
                     case 'getEncodedSemanticClassifications': return getEncodedSemanticClassifications(language, target[p]);
@@ -46,6 +47,7 @@ function createProxyLanguageService(languageService) {
                     case 'getCompletionEntryDetails': return getCompletionEntryDetails(language, target[p]);
                     case 'provideInlayHints': return provideInlayHints(language, target[p]);
                     case 'getFileReferences': return getFileReferences(language, target[p]);
+                    case 'getNavigateToItems': return getNavigateToItems(language, target[p]);
                 }
             };
         },
@@ -467,6 +469,13 @@ function getEditsForRefactor(language, getEditsForRefactor) {
         }
     };
 }
+function getCombinedCodeFix(language, getCombinedCodeFix) {
+    return (...args) => {
+        const codeActions = getCombinedCodeFix(...args);
+        codeActions.changes = (0, transform_1.transformFileTextChanges)(language, codeActions.changes, language_core_1.isCodeActionsEnabled);
+        return codeActions;
+    };
+}
 function getRenameInfo(language, getRenameInfo) {
     return (filePath, position, options) => {
         const fileName = filePath.replace(windowsPathReg, '/');
@@ -861,6 +870,15 @@ function getFileReferences(language, getFileReferences) {
         return (0, dedupe_1.dedupeDocumentSpans)(resolved);
     };
 }
+function getNavigateToItems(language, getNavigateToItems) {
+    return (...args) => {
+        const unresolved = getNavigateToItems(...args);
+        const resolved = unresolved
+            .map(s => (0, transform_1.transformDocumentSpan)(language, s, language_core_1.isReferencesEnabled))
+            .filter(s => !!s);
+        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
+    };
+}
 function linkedCodeFeatureWorker(language, fileName, position, filter, worker, getLinkedCodes) {
     const results = [];
     const processedFilePositions = new Set();

package/lib/protocol/createProject.js

@@ -9,6 +9,7 @@ function createLanguageServiceHost(ts, sys, language, asScriptId, projectHost) {
     let lastProjectVersion;
     let tsProjectVersion = 0;
     let tsFileRegistry = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
+    let tsFileDirRegistry = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
     let extraScriptRegistry = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
     let lastTsVirtualFileSnapshots = new Set();
     let lastOtherVirtualFileSnapshots = new Set();
@@ -66,6 +67,13 @@ function createLanguageServiceHost(ts, sys, language, asScriptId, projectHost) {
                 return snapshot.getText(0, snapshot.getLength());
             }
         },
+        directoryExists(directoryName) {
+            sync();
+            if (tsFileDirRegistry.has(directoryName)) {
+                return true;
+            }
+            return sys.directoryExists(directoryName);
+        },
         fileExists(fileName) {
             return getScriptVersion(fileName) !== '';
         },
@@ -119,7 +127,7 @@ function createLanguageServiceHost(ts, sys, language, asScriptId, projectHost) {
     if (language.plugins.some(plugin => plugin.typescript?.extraFileExtensions.length)) {
         // TODO: can this share between monorepo packages?
         const moduleCache = ts.createModuleResolutionCache(languageServiceHost.getCurrentDirectory(), languageServiceHost.useCaseSensitiveFileNames?.() ? s => s : s => s.toLowerCase(), languageServiceHost.getCompilationSettings());
-        const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, languageServiceHost, language.plugins, fileName => language.scripts.get(asScriptId(fileName)));
+        const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, sys.getFileSize, languageServiceHost, language.plugins, fileName => language.scripts.get(asScriptId(fileName)));
         let lastSysVersion = 'version' in sys ? sys.version : undefined;
         languageServiceHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, sourceFile) => {
             if ('version' in sys && lastSysVersion !== sys.version) {
@@ -190,8 +198,14 @@ function createLanguageServiceHost(ts, sys, language, asScriptId, projectHost) {
         lastTsVirtualFileSnapshots = newTsVirtualFileSnapshots;
         lastOtherVirtualFileSnapshots = newOtherVirtualFileSnapshots;
         tsFileRegistry.clear();
+        tsFileDirRegistry.clear();
         for (const fileName of tsFileNamesSet) {
             tsFileRegistry.set(fileName, true);
+            const parts = fileName.split('/');
+            for (let i = 1; i < parts.length; i++) {
+                const dirName = parts.slice(0, i).join('/');
+                tsFileDirRegistry.set(dirName, true);
+            }
         }
     }
     function getScriptSnapshot(fileName) {

package/lib/quickstart/createAsyncLanguageServicePlugin.d.ts

@@ -1,6 +1,6 @@
 import { Language, LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
-export declare function createAsyncLanguageServicePlugin(extensions: string[], scriptKind: ts.ScriptKind, create: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => Promise<{
+export declare function createAsyncLanguageServicePlugin(extensions: string[], getScriptKindForExtraExtensions: ts.ScriptKind | ((fileName: string) => ts.ScriptKind), create: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => Promise<{
     languagePlugins: LanguagePlugin<string>[];
     setup?: (language: Language<string>) => void;
 }>): ts.server.PluginModuleFactory;

package/lib/quickstart/createAsyncLanguageServicePlugin.js

@@ -6,7 +6,7 @@ const common_1 = require("../common");
 const proxyLanguageService_1 = require("../node/proxyLanguageService");
 const decorateLanguageServiceHost_1 = require("../node/decorateLanguageServiceHost");
 const createLanguageServicePlugin_1 = require("./createLanguageServicePlugin");
-function createAsyncLanguageServicePlugin(extensions, scriptKind, create) {
+function createAsyncLanguageServicePlugin(extensions, getScriptKindForExtraExtensions, create) {
     return modules => {
         const { typescript: ts } = modules;
         const pluginModule = {
@@ -36,7 +36,14 @@ function createAsyncLanguageServicePlugin(extensions, scriptKind, create) {
                     if (getScriptKind) {
                         info.languageServiceHost.getScriptKind = fileName => {
                             if (!initialized && extensions.some(ext => fileName.endsWith(ext))) {
-                                return scriptKind; // TODO: bypass upstream bug
+                                // bypass upstream bug https://github.com/microsoft/TypeScript/issues/57631
+                                // TODO: check if the bug is fixed in 5.5
+                                if (typeof getScriptKindForExtraExtensions === 'function') {
+                                    return getScriptKindForExtraExtensions(fileName);
+                                }
+                                else {
+                                    return getScriptKindForExtraExtensions;
+                                }
                             }
                             return getScriptKind(fileName);
                         };
@@ -52,17 +59,11 @@ function createAsyncLanguageServicePlugin(extensions, scriptKind, create) {
                     const { proxy, initialize } = (0, proxyLanguageService_1.createProxyLanguageService)(info.languageService);
                     info.languageService = proxy;
                     create(ts, info).then(({ languagePlugins, setup }) => {
-                        const syncedScriptVersions = new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames);
                         const language = (0, language_core_1.createLanguage)([
                             ...languagePlugins,
                             { getLanguageId: common_1.resolveFileLanguageId },
                         ], new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames), fileName => {
-                            const version = getScriptVersion(fileName);
-                            if (syncedScriptVersions.get(fileName) === version) {
-                                return;
-                            }
-                            syncedScriptVersions.set(fileName, version);
-                            const snapshot = getScriptSnapshot(fileName);
+                            const snapshot = info.project.getScriptInfo(fileName)?.getSnapshot();
                             if (snapshot) {
                                 language.scripts.set(fileName, snapshot);
                             }

package/lib/quickstart/createLanguageServicePlugin.js

@@ -25,19 +25,11 @@ function createLanguageServicePlugin(create) {
                         .map(plugin => plugin.typescript?.extraFileExtensions.map(ext => '.' + ext.extension) ?? [])
                         .flat();
                     exports.projectExternalFileExtensions.set(info.project, extensions);
-                    const getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
-                    const getScriptVersion = info.languageServiceHost.getScriptVersion.bind(info.languageServiceHost);
-                    const syncedScriptVersions = new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames);
                     const language = (0, language_core_1.createLanguage)([
                         ...languagePlugins,
                         { getLanguageId: common_1.resolveFileLanguageId },
                     ], new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames), fileName => {
-                        const version = getScriptVersion(fileName);
-                        if (syncedScriptVersions.get(fileName) === version) {
-                            return;
-                        }
-                        syncedScriptVersions.set(fileName, version);
-                        const snapshot = getScriptSnapshot(fileName);
+                        const snapshot = info.project.getScriptInfo(fileName)?.getSnapshot();
                         if (snapshot) {
                             language.scripts.set(fileName, snapshot);
                         }

package/lib/quickstart/runTsc.d.ts

@@ -4,4 +4,7 @@ export declare let getLanguagePlugins: (ts: typeof import('typescript'), options
     languagePlugins: LanguagePlugin<string>[];
     setup?(language: Language<string>): void;
 };
-export declare function runTsc(tscPath: string, extensions: string[], _getLanguagePlugins: typeof getLanguagePlugins): void;
+export declare function runTsc(tscPath: string, options: string[] | {
+    extraSupportedExtensions: string[];
+    extraExtensionsToRemove: string[];
+}, _getLanguagePlugins: typeof getLanguagePlugins): void;

package/lib/quickstart/runTsc.js

@@ -5,18 +5,45 @@ exports.runTsc = runTsc;
 const fs = require("fs");
 let getLanguagePlugins = () => [];
 exports.getLanguagePlugins = getLanguagePlugins;
-function runTsc(tscPath, extensions, _getLanguagePlugins) {
+function runTsc(tscPath, options, _getLanguagePlugins) {
     exports.getLanguagePlugins = _getLanguagePlugins;
     const proxyApiPath = require.resolve('../node/proxyCreateProgram');
     const readFileSync = fs.readFileSync;
     fs.readFileSync = (...args) => {
         if (args[0] === tscPath) {
             let tsc = readFileSync(...args);
-            // add allow extensions
-            const extsText = extensions.map(ext => `"${ext}"`).join(', ');
-            tsc = replace(tsc, /supportedTSExtensions = .*(?=;)/, s => s + `.concat([[${extsText}]])`);
-            tsc = replace(tsc, /supportedJSExtensions = .*(?=;)/, s => s + `.concat([[${extsText}]])`);
-            tsc = replace(tsc, /allSupportedExtensions = .*(?=;)/, s => s + `.concat([[${extsText}]])`);
+            let extraSupportedExtensions;
+            let extraExtensionsToRemove;
+            if (Array.isArray(options)) {
+                extraSupportedExtensions = options;
+                extraExtensionsToRemove = [];
+            }
+            else {
+                extraSupportedExtensions = options.extraSupportedExtensions;
+                extraExtensionsToRemove = options.extraExtensionsToRemove;
+            }
+            const needPatchExtenstions = extraSupportedExtensions.filter(ext => !extraExtensionsToRemove.includes(ext));
+            // Add allow extensions
+            if (extraSupportedExtensions.length) {
+                const extsText = extraSupportedExtensions.map(ext => `"${ext}"`).join(', ');
+                tsc = replace(tsc, /supportedTSExtensions = .*(?=;)/, s => s + `.map((group, i) => i === 0 ? group.splice(0, 0, ${extsText}) && group : group)`);
+                tsc = replace(tsc, /supportedJSExtensions = .*(?=;)/, s => s + `.map((group, i) => i === 0 ? group.splice(0, 0, ${extsText}) && group : group)`);
+                tsc = replace(tsc, /allSupportedExtensions = .*(?=;)/, s => s + `.map((group, i) => i === 0 ? group.splice(0, 0, ${extsText}) && group : group)`);
+            }
+            // Use to emit basename.xxx to basename.d.ts instead of basename.xxx.d.ts
+            if (extraExtensionsToRemove.length) {
+                const extsText = extraExtensionsToRemove.map(ext => `"${ext}"`).join(', ');
+                tsc = replace(tsc, /extensionsToRemove = .*(?=;)/, s => s + `.concat([${extsText}])`);
+            }
+            // Support for basename.xxx to basename.xxx.d.ts
+            if (needPatchExtenstions.length) {
+                const extsText = needPatchExtenstions.map(ext => `"${ext}"`).join(', ');
+                tsc = replace(tsc, /function changeExtension\(/, s => `function changeExtension(path, newExtension) {
+					return [${extsText}].some(ext => path.endsWith(ext))
+						? path + newExtension
+						: _changeExtension(path, newExtension)
+					}\n` + s.replace('changeExtension', '_changeExtension'));
+            }
             // proxy createProgram
             tsc = replace(tsc, /function createProgram\(.+\) {/, s => `var createProgram = require(${JSON.stringify(proxyApiPath)}).proxyCreateProgram(`
                 + [

package/lib/resolveModuleName.d.ts

@@ -1,3 +1,3 @@
 import type { LanguagePlugin, SourceScript } from '@volar/language-core';
 import type * as ts from 'typescript';
-export declare function createResolveModuleName<T>(ts: typeof import('typescript'), host: ts.ModuleResolutionHost, languagePlugins: LanguagePlugin<any>[], getSourceScript: (fileName: string) => SourceScript<T> | undefined): (moduleName: string, containingFile: string, compilerOptions: ts.CompilerOptions, cache?: ts.ModuleResolutionCache, redirectedReference?: ts.ResolvedProjectReference, resolutionMode?: ts.ResolutionMode) => ts.ResolvedModuleWithFailedLookupLocations;
+export declare function createResolveModuleName<T>(ts: typeof import('typescript'), getFileSize: ((fileName: string) => number) | undefined, host: ts.ModuleResolutionHost, languagePlugins: LanguagePlugin<any>[], getSourceScript: (fileName: string) => SourceScript<T> | undefined): (moduleName: string, containingFile: string, compilerOptions: ts.CompilerOptions, cache?: ts.ModuleResolutionCache, redirectedReference?: ts.ResolvedProjectReference, resolutionMode?: ts.ResolutionMode) => ts.ResolvedModuleWithFailedLookupLocations;

package/lib/resolveModuleName.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createResolveModuleName = createResolveModuleName;
-function createResolveModuleName(ts, host, languagePlugins, getSourceScript) {
+function createResolveModuleName(ts, getFileSize, host, languagePlugins, getSourceScript) {
     const toSourceFileInfo = new Map();
     const moduleResolutionHost = {
         readFile: host.readFile.bind(host),
@@ -81,7 +81,7 @@ function createResolveModuleName(ts, host, languagePlugins, getSourceScript) {
     // fix https://github.com/vuejs/language-tools/issues/3332
     function fileExists(fileName) {
         if (host.fileExists(fileName)) {
-            const fileSize = ts.sys.getFileSize?.(fileName) ?? host.readFile(fileName)?.length ?? 0;
+            const fileSize = getFileSize?.(fileName) ?? host.readFile(fileName)?.length ?? 0;
             return fileSize < 4 * 1024 * 1024;
         }
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/typescript",
-	"version": "2.4.0-alpha.2",
+	"version": "2.4.0-alpha.20",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,14 +12,14 @@
 		"directory": "packages/typescript"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.4.0-alpha.2",
+		"@volar/language-core": "2.4.0-alpha.20",
 		"path-browserify": "^1.0.1",
 		"vscode-uri": "^3.0.8"
 	},
 	"devDependencies": {
 		"@types/node": "latest",
 		"@types/path-browserify": "latest",
-		"@volar/language-service": "2.4.0-alpha.2"
+		"@volar/language-service": "2.4.0-alpha.20"
 	},
-	"gitHead": "62914047f925b79391fee6e4f697705b77641baf"
+	"gitHead": "63ec0dfd91333c91a7c6443cedc1ae074b317867"
 }

package/lib/node/decorateLanguageService.d.ts

@@ -1,3 +0,0 @@
-import { Language } from '@volar/language-core';
-import type * as ts from 'typescript';
-export declare function decorateLanguageService(language: Language<string>, languageService: ts.LanguageService): void;

package/lib/node/decorateLanguageService.js

@@ -1,786 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decorateLanguageService = decorateLanguageService;
-const language_core_1 = require("@volar/language-core");
-const dedupe_1 = require("./dedupe");
-const transform_1 = require("./transform");
-const utils_1 = require("./utils");
-const windowsPathReg = /\\/g;
-function decorateLanguageService(language, languageService) {
-    // ignored methods
-    const { getNavigationTree, getOutliningSpans, } = languageService;
-    languageService.getNavigationTree = filePath => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (serviceScript || targetScript?.associatedOnly) {
-            const tree = getNavigationTree(targetScript.id);
-            tree.childItems = undefined;
-            return tree;
-        }
-        else {
-            return getNavigationTree(fileName);
-        }
-    };
-    languageService.getOutliningSpans = filePath => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (serviceScript || targetScript?.associatedOnly) {
-            return [];
-        }
-        else {
-            return getOutliningSpans(fileName);
-        }
-    };
-    // methods
-    const { findReferences, findRenameLocations, getCompletionEntryDetails, getCompletionsAtPosition, getDefinitionAndBoundSpan, getDefinitionAtPosition, getFileReferences, getFormattingEditsForDocument, getFormattingEditsForRange, getFormattingEditsAfterKeystroke, getImplementationAtPosition, getLinkedEditingRangeAtPosition, getQuickInfoAtPosition, getSignatureHelpItems, getReferencesAtPosition, getSemanticDiagnostics, getSyntacticDiagnostics, getSuggestionDiagnostics, getTypeDefinitionAtPosition, getEncodedSemanticClassifications, getDocumentHighlights, getApplicableRefactors, getEditsForFileRename, getEditsForRefactor, getRenameInfo, getCodeFixesAtPosition, prepareCallHierarchy, provideCallHierarchyIncomingCalls, provideCallHierarchyOutgoingCalls, provideInlayHints, organizeImports, } = languageService;
-    languageService.getFormattingEditsForDocument = (filePath, options) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        if (serviceScript) {
-            const map = language.maps.get(serviceScript.code, targetScript);
-            if (!map.mappings.some(mapping => (0, language_core_1.isFormattingEnabled)(mapping.data))) {
-                return [];
-            }
-            const edits = getFormattingEditsForDocument(targetScript.id, options);
-            return edits
-                .map(edit => (0, transform_1.transformTextChange)(sourceScript, language, serviceScript, edit, language_core_1.isFormattingEnabled)?.[1])
-                .filter(edit => !!edit);
-        }
-        else {
-            return getFormattingEditsForDocument(fileName, options);
-        }
-    };
-    languageService.getFormattingEditsForRange = (filePath, start, end, options) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        if (serviceScript) {
-            const generateStart = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, start, language_core_1.isFormattingEnabled);
-            const generateEnd = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, end, language_core_1.isFormattingEnabled);
-            if (generateStart !== undefined && generateEnd !== undefined) {
-                const edits = getFormattingEditsForRange(targetScript.id, generateStart, generateEnd, options);
-                return edits
-                    .map(edit => (0, transform_1.transformTextChange)(sourceScript, language, serviceScript, edit, language_core_1.isFormattingEnabled)?.[1])
-                    .filter(edit => !!edit);
-            }
-            return [];
-        }
-        else {
-            return getFormattingEditsForRange(fileName, start, end, options);
-        }
-    };
-    languageService.getFormattingEditsAfterKeystroke = (filePath, position, key, options) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        if (serviceScript) {
-            const generatePosition = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, position, language_core_1.isFormattingEnabled);
-            if (generatePosition !== undefined) {
-                const edits = getFormattingEditsAfterKeystroke(targetScript.id, generatePosition, key, options);
-                return edits
-                    .map(edit => (0, transform_1.transformTextChange)(sourceScript, language, serviceScript, edit, language_core_1.isFormattingEnabled)?.[1])
-                    .filter(edit => !!edit);
-            }
-            return [];
-        }
-        else {
-            return getFormattingEditsAfterKeystroke(fileName, position, key, options);
-        }
-    };
-    languageService.getEditsForFileRename = (oldFilePath, newFilePath, formatOptions, preferences) => {
-        const edits = getEditsForFileRename(oldFilePath, newFilePath, formatOptions, preferences);
-        return (0, transform_1.transformFileTextChanges)(language, edits, language_core_1.isRenameEnabled);
-    };
-    languageService.getLinkedEditingRangeAtPosition = (filePath, position) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return undefined;
-        }
-        if (serviceScript) {
-            const generatePosition = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, position, language_core_1.isLinkedEditingEnabled);
-            if (generatePosition !== undefined) {
-                const info = getLinkedEditingRangeAtPosition(targetScript.id, generatePosition);
-                if (info) {
-                    return {
-                        ranges: info.ranges
-                            .map(span => (0, transform_1.transformTextSpan)(sourceScript, language, serviceScript, span, language_core_1.isLinkedEditingEnabled)?.[1])
-                            .filter(span => !!span),
-                        wordPattern: info.wordPattern,
-                    };
-                }
-            }
-        }
-        else {
-            return getLinkedEditingRangeAtPosition(fileName, position);
-        }
-    };
-    languageService.prepareCallHierarchy = (filePath, position) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return undefined;
-        }
-        if (serviceScript) {
-            const generatePosition = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, position, language_core_1.isCallHierarchyEnabled);
-            if (generatePosition !== undefined) {
-                const item = prepareCallHierarchy(targetScript.id, generatePosition);
-                if (Array.isArray(item)) {
-                    return item.map(item => (0, transform_1.transformCallHierarchyItem)(language, item, language_core_1.isCallHierarchyEnabled));
-                }
-                else if (item) {
-                    return (0, transform_1.transformCallHierarchyItem)(language, item, language_core_1.isCallHierarchyEnabled);
-                }
-            }
-        }
-        else {
-            return prepareCallHierarchy(fileName, position);
-        }
-    };
-    languageService.provideCallHierarchyIncomingCalls = (filePath, position) => {
-        let calls = [];
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        if (serviceScript) {
-            const generatePosition = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, position, language_core_1.isCallHierarchyEnabled);
-            if (generatePosition !== undefined) {
-                calls = provideCallHierarchyIncomingCalls(targetScript.id, generatePosition);
-            }
-        }
-        else {
-            calls = provideCallHierarchyIncomingCalls(fileName, position);
-        }
-        return calls
-            .map(call => {
-            const from = (0, transform_1.transformCallHierarchyItem)(language, call.from, language_core_1.isCallHierarchyEnabled);
-            const fromSpans = call.fromSpans
-                .map(span => (0, transform_1.transformSpan)(language, call.from.file, span, language_core_1.isCallHierarchyEnabled)?.textSpan)
-                .filter(span => !!span);
-            return {
-                from,
-                fromSpans,
-            };
-        });
-    };
-    languageService.provideCallHierarchyOutgoingCalls = (filePath, position) => {
-        let calls = [];
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        if (serviceScript) {
-            const generatePosition = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, position, language_core_1.isCallHierarchyEnabled);
-            if (generatePosition !== undefined) {
-                calls = provideCallHierarchyOutgoingCalls(targetScript.id, generatePosition);
-            }
-        }
-        else {
-            calls = provideCallHierarchyOutgoingCalls(fileName, position);
-        }
-        return calls
-            .map(call => {
-            const to = (0, transform_1.transformCallHierarchyItem)(language, call.to, language_core_1.isCallHierarchyEnabled);
-            const fromSpans = call.fromSpans
-                .map(span => serviceScript
-                ? (0, transform_1.transformTextSpan)(sourceScript, language, serviceScript, span, language_core_1.isCallHierarchyEnabled)?.[1]
-                : span)
-                .filter(span => !!span);
-            return {
-                to,
-                fromSpans,
-            };
-        });
-    };
-    languageService.organizeImports = (args, formatOptions, preferences) => {
-        const unresolved = organizeImports(args, formatOptions, preferences);
-        return (0, transform_1.transformFileTextChanges)(language, unresolved, language_core_1.isCodeActionsEnabled);
-    };
-    languageService.getQuickInfoAtPosition = (filePath, position) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return undefined;
-        }
-        if (serviceScript) {
-            const infos = [];
-            for (const [generatePosition] of (0, transform_1.toGeneratedOffsets)(language, serviceScript, sourceScript, position, language_core_1.isHoverEnabled)) {
-                const info = getQuickInfoAtPosition(targetScript.id, generatePosition);
-                if (info) {
-                    const textSpan = (0, transform_1.transformTextSpan)(sourceScript, language, serviceScript, info.textSpan, language_core_1.isHoverEnabled)?.[1];
-                    if (textSpan) {
-                        infos.push({
-                            ...info,
-                            textSpan: textSpan,
-                        });
-                    }
-                }
-            }
-            if (infos.length === 1) {
-                return infos[0];
-            }
-            else if (infos.length >= 2) {
-                const combine = { ...infos[0] };
-                combine.displayParts = combine.displayParts?.slice();
-                combine.documentation = combine.documentation?.slice();
-                combine.tags = combine.tags?.slice();
-                const displayPartsStrs = new Set([displayPartsToString(infos[0].displayParts)]);
-                const documentationStrs = new Set([displayPartsToString(infos[0].documentation)]);
-                const tagsStrs = new Set();
-                for (const tag of infos[0].tags ?? []) {
-                    tagsStrs.add(tag.name + '__volar__' + displayPartsToString(tag.text));
-                }
-                for (let i = 1; i < infos.length; i++) {
-                    const { displayParts, documentation, tags } = infos[i];
-                    if (displayParts?.length && !displayPartsStrs.has(displayPartsToString(displayParts))) {
-                        displayPartsStrs.add(displayPartsToString(displayParts));
-                        combine.displayParts ??= [];
-                        combine.displayParts.push({ ...displayParts[0], text: '\n\n' + displayParts[0].text });
-                        combine.displayParts.push(...displayParts.slice(1));
-                    }
-                    if (documentation?.length && !documentationStrs.has(displayPartsToString(documentation))) {
-                        documentationStrs.add(displayPartsToString(documentation));
-                        combine.documentation ??= [];
-                        combine.documentation.push({ ...documentation[0], text: '\n\n' + documentation[0].text });
-                        combine.documentation.push(...documentation.slice(1));
-                    }
-                    for (const tag of tags ?? []) {
-                        if (!tagsStrs.has(tag.name + '__volar__' + displayPartsToString(tag.text))) {
-                            tagsStrs.add(tag.name + '__volar__' + displayPartsToString(tag.text));
-                            combine.tags ??= [];
-                            combine.tags.push(tag);
-                        }
-                    }
-                }
-                return combine;
-            }
-        }
-        else {
-            return getQuickInfoAtPosition(fileName, position);
-        }
-    };
-    languageService.getSignatureHelpItems = (filePath, position, options) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return undefined;
-        }
-        if (serviceScript) {
-            const generatePosition = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, position, language_core_1.isSignatureHelpEnabled);
-            if (generatePosition !== undefined) {
-                const result = getSignatureHelpItems(targetScript.id, generatePosition, options);
-                if (result) {
-                    const applicableSpan = (0, transform_1.transformTextSpan)(sourceScript, language, serviceScript, result.applicableSpan, language_core_1.isSignatureHelpEnabled)?.[1];
-                    if (applicableSpan) {
-                        return {
-                            ...result,
-                            applicableSpan,
-                        };
-                    }
-                }
-            }
-        }
-        else {
-            return getSignatureHelpItems(fileName, position, options);
-        }
-    };
-    languageService.getDocumentHighlights = (filePath, position, filesToSearch) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isHighlightEnabled, (fileName, position) => getDocumentHighlights(fileName, position, filesToSearch), function* (result) {
-            for (const ref of result) {
-                for (const reference of ref.highlightSpans) {
-                    yield [reference.fileName ?? ref.fileName, reference.textSpan.start];
-                }
-            }
-        });
-        const resolved = unresolved
-            .flat()
-            .map(highlights => {
-            return {
-                ...highlights,
-                highlightSpans: highlights.highlightSpans
-                    .map(span => {
-                    const { textSpan } = (0, transform_1.transformSpan)(language, span.fileName ?? highlights.fileName, span.textSpan, language_core_1.isHighlightEnabled) ?? {};
-                    if (textSpan) {
-                        return {
-                            ...span,
-                            contextSpan: (0, transform_1.transformSpan)(language, span.fileName ?? highlights.fileName, span.contextSpan, language_core_1.isHighlightEnabled)?.textSpan,
-                            textSpan,
-                        };
-                    }
-                })
-                    .filter(span => !!span),
-            };
-        });
-        return resolved;
-    };
-    languageService.getApplicableRefactors = (filePath, positionOrRange, preferences, triggerReason, kind, includeInteractiveActions) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        if (serviceScript) {
-            if (typeof positionOrRange === 'number') {
-                const generatePosition = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, positionOrRange, language_core_1.isCodeActionsEnabled);
-                if (generatePosition !== undefined) {
-                    return getApplicableRefactors(targetScript.id, generatePosition, preferences, triggerReason, kind, includeInteractiveActions);
-                }
-            }
-            else {
-                for (const [generatedStart, generatedEnd] of (0, transform_1.toGeneratedRanges)(language, serviceScript, sourceScript, positionOrRange.pos, positionOrRange.end, language_core_1.isCodeActionsEnabled)) {
-                    return getApplicableRefactors(targetScript.id, { pos: generatedStart, end: generatedEnd }, preferences, triggerReason, kind, includeInteractiveActions);
-                }
-            }
-            return [];
-        }
-        else {
-            return getApplicableRefactors(fileName, positionOrRange, preferences, triggerReason, kind, includeInteractiveActions);
-        }
-    };
-    languageService.getEditsForRefactor = (filePath, formatOptions, positionOrRange, refactorName, actionName, preferences) => {
-        let edits;
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return undefined;
-        }
-        if (serviceScript) {
-            if (typeof positionOrRange === 'number') {
-                const generatePosition = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, positionOrRange, language_core_1.isCodeActionsEnabled);
-                if (generatePosition !== undefined) {
-                    edits = getEditsForRefactor(targetScript.id, formatOptions, generatePosition, refactorName, actionName, preferences);
-                }
-            }
-            else {
-                for (const [generatedStart, generatedEnd] of (0, transform_1.toGeneratedRanges)(language, serviceScript, sourceScript, positionOrRange.pos, positionOrRange.end, language_core_1.isCodeActionsEnabled)) {
-                    edits = getEditsForRefactor(targetScript.id, formatOptions, { pos: generatedStart, end: generatedEnd }, refactorName, actionName, preferences);
-                }
-            }
-        }
-        else {
-            edits = getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, preferences);
-        }
-        if (edits) {
-            edits.edits = (0, transform_1.transformFileTextChanges)(language, edits.edits, language_core_1.isCodeActionsEnabled);
-            return edits;
-        }
-    };
-    languageService.getRenameInfo = (filePath, position, options) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return {
-                canRename: false,
-                localizedErrorMessage: "Cannot rename"
-            };
-        }
-        if (serviceScript) {
-            let failed;
-            for (const [generateOffset] of (0, transform_1.toGeneratedOffsets)(language, serviceScript, sourceScript, position, language_core_1.isRenameEnabled)) {
-                const info = getRenameInfo(targetScript.id, generateOffset, options);
-                if (info.canRename) {
-                    const span = (0, transform_1.transformTextSpan)(sourceScript, language, serviceScript, info.triggerSpan, language_core_1.isRenameEnabled)?.[1];
-                    if (span) {
-                        info.triggerSpan = span;
-                        return info;
-                    }
-                }
-                else {
-                    failed = info;
-                }
-            }
-            if (failed) {
-                return failed;
-            }
-            return {
-                canRename: false,
-                localizedErrorMessage: 'Failed to get rename locations',
-            };
-        }
-        else {
-            return getRenameInfo(fileName, position, options);
-        }
-    };
-    languageService.getCodeFixesAtPosition = (filePath, start, end, errorCodes, formatOptions, preferences) => {
-        let fixes = [];
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        if (serviceScript) {
-            const generateStart = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, start, language_core_1.isCodeActionsEnabled);
-            const generateEnd = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, end, language_core_1.isCodeActionsEnabled);
-            if (generateStart !== undefined && generateEnd !== undefined) {
-                fixes = getCodeFixesAtPosition(targetScript.id, generateStart, generateEnd, errorCodes, formatOptions, preferences);
-            }
-        }
-        else {
-            fixes = getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions, preferences);
-        }
-        fixes = fixes.map(fix => {
-            fix.changes = (0, transform_1.transformFileTextChanges)(language, fix.changes, language_core_1.isCodeActionsEnabled);
-            return fix;
-        });
-        return fixes;
-    };
-    languageService.getEncodedSemanticClassifications = (filePath, span, format) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return {
-                spans: [],
-                endOfLineState: 0
-            };
-        }
-        if (serviceScript) {
-            let start;
-            let end;
-            const map = language.maps.get(serviceScript.code, targetScript);
-            for (const mapping of map.mappings) {
-                // TODO reuse the logic from language service
-                if ((0, language_core_1.isSemanticTokensEnabled)(mapping.data) && mapping.sourceOffsets[0] >= span.start && mapping.sourceOffsets[0] <= span.start + span.length) {
-                    start ??= mapping.generatedOffsets[0];
-                    end ??= mapping.generatedOffsets[mapping.generatedOffsets.length - 1] + (mapping.generatedLengths ?? mapping.lengths)[mapping.lengths.length - 1];
-                    start = Math.min(start, mapping.generatedOffsets[0]);
-                    end = Math.max(end, mapping.generatedOffsets[mapping.generatedOffsets.length - 1] + (mapping.generatedLengths ?? mapping.lengths)[mapping.lengths.length - 1]);
-                }
-            }
-            start ??= 0;
-            end ??= targetScript.snapshot.getLength();
-            const mappingOffset = (0, transform_1.getMappingOffset)(language, serviceScript);
-            start += mappingOffset;
-            end += mappingOffset;
-            const result = getEncodedSemanticClassifications(targetScript.id, { start, length: end - start }, format);
-            const spans = [];
-            for (let i = 0; i < result.spans.length; i += 3) {
-                for (const [_, sourceStart, sourceEnd] of (0, transform_1.toSourceRanges)(sourceScript, language, serviceScript, result.spans[i], result.spans[i] + result.spans[i + 1], language_core_1.isSemanticTokensEnabled)) {
-                    spans.push(sourceStart, sourceEnd - sourceStart, result.spans[i + 2]);
-                    break;
-                }
-            }
-            result.spans = spans;
-            return result;
-        }
-        else {
-            return getEncodedSemanticClassifications(fileName, span, format);
-        }
-    };
-    languageService.getSyntacticDiagnostics = filePath => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        return getSyntacticDiagnostics(targetScript?.id ?? fileName)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d, languageService.getProgram(), false))
-            .filter(d => !!d)
-            .filter(d => !serviceScript || language.scripts.get(d.file.fileName) === sourceScript);
-    };
-    languageService.getSemanticDiagnostics = filePath => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        return getSemanticDiagnostics(targetScript?.id ?? fileName)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d, languageService.getProgram(), false))
-            .filter(d => !!d)
-            .filter(d => !serviceScript || !d.file || language.scripts.get(d.file.fileName) === sourceScript);
-    };
-    languageService.getSuggestionDiagnostics = filePath => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        return getSuggestionDiagnostics(targetScript?.id ?? fileName)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d, languageService.getProgram(), false))
-            .filter(d => !!d)
-            .filter(d => !serviceScript || !d.file || language.scripts.get(d.file.fileName) === sourceScript);
-    };
-    languageService.getDefinitionAndBoundSpan = (filePath, position) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isDefinitionEnabled, (fileName, position) => getDefinitionAndBoundSpan(fileName, position), function* (result) {
-            for (const ref of result.definitions ?? []) {
-                yield [ref.fileName, ref.textSpan.start];
-            }
-        });
-        const textSpan = unresolved
-            .map(s => (0, transform_1.transformSpan)(language, fileName, s.textSpan, language_core_1.isDefinitionEnabled)?.textSpan)
-            .filter(s => !!s)[0];
-        if (!textSpan) {
-            return;
-        }
-        const definitions = unresolved
-            .map(s => s.definitions
-            ?.map(s => (0, transform_1.transformDocumentSpan)(language, s, language_core_1.isDefinitionEnabled, s.fileName !== fileName))
-            .filter(s => !!s)
-            ?? [])
-            .flat();
-        return {
-            textSpan,
-            definitions: (0, dedupe_1.dedupeDocumentSpans)(definitions),
-        };
-    };
-    languageService.findReferences = (filePath, position) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isReferencesEnabled, (fileName, position) => findReferences(fileName, position), function* (result) {
-            for (const ref of result) {
-                for (const reference of ref.references) {
-                    yield [reference.fileName, reference.textSpan.start];
-                }
-            }
-        });
-        const resolved = unresolved
-            .flat()
-            .map(symbol => {
-            const definition = (0, transform_1.transformDocumentSpan)(language, symbol.definition, language_core_1.isDefinitionEnabled, true);
-            return {
-                definition,
-                references: symbol.references
-                    .map(r => (0, transform_1.transformDocumentSpan)(language, r, language_core_1.isReferencesEnabled))
-                    .filter(r => !!r),
-            };
-        });
-        return resolved;
-    };
-    languageService.getDefinitionAtPosition = (filePath, position) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isDefinitionEnabled, (fileName, position) => getDefinitionAtPosition(fileName, position), function* (result) {
-            for (const ref of result) {
-                yield [ref.fileName, ref.textSpan.start];
-            }
-        });
-        const resolved = unresolved
-            .flat()
-            .map(s => (0, transform_1.transformDocumentSpan)(language, s, language_core_1.isDefinitionEnabled, s.fileName !== fileName))
-            .filter(s => !!s);
-        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
-    };
-    languageService.getTypeDefinitionAtPosition = (filePath, position) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isTypeDefinitionEnabled, (fileName, position) => getTypeDefinitionAtPosition(fileName, position), function* (result) {
-            for (const ref of result) {
-                yield [ref.fileName, ref.textSpan.start];
-            }
-        });
-        const resolved = unresolved
-            .flat()
-            .map(s => (0, transform_1.transformDocumentSpan)(language, s, language_core_1.isTypeDefinitionEnabled))
-            .filter(s => !!s);
-        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
-    };
-    languageService.getImplementationAtPosition = (filePath, position) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isImplementationEnabled, (fileName, position) => getImplementationAtPosition(fileName, position), function* (result) {
-            for (const ref of result) {
-                yield [ref.fileName, ref.textSpan.start];
-            }
-        });
-        const resolved = unresolved
-            .flat()
-            .map(s => (0, transform_1.transformDocumentSpan)(language, s, language_core_1.isImplementationEnabled))
-            .filter(s => !!s);
-        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
-    };
-    languageService.findRenameLocations = (filePath, position, findInStrings, findInComments, preferences) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isRenameEnabled, (fileName, position) => findRenameLocations(fileName, position, findInStrings, findInComments, preferences), function* (result) {
-            for (const ref of result) {
-                yield [ref.fileName, ref.textSpan.start];
-            }
-        });
-        const resolved = unresolved
-            .flat()
-            .map(s => (0, transform_1.transformDocumentSpan)(language, s, language_core_1.isRenameEnabled))
-            .filter(s => !!s);
-        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
-    };
-    languageService.getReferencesAtPosition = (filePath, position) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isReferencesEnabled, (fileName, position) => getReferencesAtPosition(fileName, position), function* (result) {
-            for (const ref of result) {
-                yield [ref.fileName, ref.textSpan.start];
-            }
-        });
-        const resolved = unresolved
-            .flat()
-            .map(s => (0, transform_1.transformDocumentSpan)(language, s, language_core_1.isReferencesEnabled))
-            .filter(s => !!s);
-        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
-    };
-    languageService.getCompletionsAtPosition = (filePath, position, options, formattingSettings) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return undefined;
-        }
-        if (serviceScript) {
-            const results = [];
-            for (const [generatedOffset, mapping] of (0, transform_1.toGeneratedOffsets)(language, serviceScript, sourceScript, position, language_core_1.isCompletionEnabled)) {
-                const result = getCompletionsAtPosition(targetScript.id, generatedOffset, options, formattingSettings);
-                if (!result) {
-                    continue;
-                }
-                if (typeof mapping.data.completion === 'object' && mapping.data.completion.onlyImport) {
-                    result.entries = result.entries.filter(entry => !!entry.sourceDisplay);
-                }
-                for (const entry of result.entries) {
-                    entry.replacementSpan = entry.replacementSpan && (0, transform_1.transformTextSpan)(sourceScript, language, serviceScript, entry.replacementSpan, language_core_1.isCompletionEnabled)?.[1];
-                }
-                result.optionalReplacementSpan = result.optionalReplacementSpan
-                    && (0, transform_1.transformTextSpan)(sourceScript, language, serviceScript, result.optionalReplacementSpan, language_core_1.isCompletionEnabled)?.[1];
-                const isAdditional = typeof mapping.data.completion === 'object' && mapping.data.completion.isAdditional;
-                if (isAdditional) {
-                    results.push(result);
-                }
-                else {
-                    results.unshift(result);
-                }
-            }
-            if (results.length) {
-                return {
-                    ...results[0],
-                    entries: results
-                        .map(additionalResult => additionalResult.entries)
-                        .flat(),
-                };
-            }
-        }
-        else {
-            return getCompletionsAtPosition(fileName, position, options, formattingSettings);
-        }
-    };
-    languageService.getCompletionEntryDetails = (filePath, position, entryName, formatOptions, source, preferences, data) => {
-        let details;
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return undefined;
-        }
-        if (serviceScript) {
-            const generatePosition = (0, transform_1.toGeneratedOffset)(language, serviceScript, sourceScript, position, language_core_1.isCompletionEnabled);
-            if (generatePosition !== undefined) {
-                details = getCompletionEntryDetails(targetScript.id, generatePosition, entryName, formatOptions, source, preferences, data);
-            }
-        }
-        else {
-            return getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data);
-        }
-        if (details?.codeActions) {
-            for (const codeAction of details.codeActions) {
-                codeAction.changes = (0, transform_1.transformFileTextChanges)(language, codeAction.changes, language_core_1.isCompletionEnabled);
-            }
-        }
-        return details;
-    };
-    languageService.provideInlayHints = (filePath, span, preferences) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (targetScript?.associatedOnly) {
-            return [];
-        }
-        if (serviceScript) {
-            let start;
-            let end;
-            const map = language.maps.get(serviceScript.code, targetScript);
-            for (const mapping of map.mappings) {
-                if ((0, language_core_1.isInlayHintsEnabled)(mapping.data) && mapping.sourceOffsets[0] >= span.start && mapping.sourceOffsets[0] <= span.start + span.length) {
-                    start ??= mapping.generatedOffsets[0];
-                    end ??= mapping.generatedOffsets[mapping.generatedOffsets.length - 1];
-                    start = Math.min(start, mapping.generatedOffsets[0]);
-                    end = Math.max(end, mapping.generatedOffsets[mapping.generatedOffsets.length - 1]);
-                }
-            }
-            if (start === undefined || end === undefined) {
-                start = 0;
-                end = 0;
-            }
-            const mappingOffset = (0, transform_1.getMappingOffset)(language, serviceScript);
-            start += mappingOffset;
-            end += mappingOffset;
-            const result = provideInlayHints(targetScript.id, { start, length: end - start }, preferences);
-            const hints = [];
-            for (const hint of result) {
-                const sourcePosition = (0, transform_1.toSourceOffset)(sourceScript, language, serviceScript, hint.position, language_core_1.isInlayHintsEnabled);
-                if (sourcePosition !== undefined) {
-                    hints.push({
-                        ...hint,
-                        position: sourcePosition[1],
-                    });
-                }
-            }
-            return hints;
-        }
-        else {
-            return provideInlayHints(fileName, span, preferences);
-        }
-    };
-    languageService.getFileReferences = filePath => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const unresolved = getFileReferences(fileName);
-        const resolved = unresolved
-            .map(s => (0, transform_1.transformDocumentSpan)(language, s, language_core_1.isReferencesEnabled))
-            .filter(s => !!s);
-        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
-    };
-    function linkedCodeFeatureWorker(fileName, position, filter, worker, getLinkedCodes) {
-        const results = [];
-        const processedFilePositions = new Set();
-        const [serviceScript, targetScript, sourceScript] = (0, utils_1.getServiceScript)(language, fileName);
-        if (serviceScript) {
-            for (const [generatedOffset] of (0, transform_1.toGeneratedOffsets)(language, serviceScript, sourceScript, position, filter)) {
-                process(targetScript.id, generatedOffset);
-            }
-        }
-        else {
-            process(fileName, position);
-        }
-        return results;
-        function process(fileName, position) {
-            if (processedFilePositions.has(fileName + ':' + position)) {
-                return;
-            }
-            processedFilePositions.add(fileName + ':' + position);
-            const result = worker(fileName, position);
-            if (!result) {
-                return;
-            }
-            results.push(result);
-            for (const ref of getLinkedCodes(result)) {
-                processedFilePositions.add(ref[0] + ':' + ref[1]);
-                const [serviceScript] = (0, utils_1.getServiceScript)(language, ref[0]);
-                if (!serviceScript) {
-                    continue;
-                }
-                const linkedCodeMap = language.linkedCodeMaps.get(serviceScript.code);
-                if (!linkedCodeMap) {
-                    continue;
-                }
-                const mappingOffset = (0, transform_1.getMappingOffset)(language, serviceScript);
-                for (const linkedCodeOffset of linkedCodeMap.getLinkedOffsets(ref[1] - mappingOffset)) {
-                    process(ref[0], linkedCodeOffset + mappingOffset);
-                }
-            }
-        }
-    }
-}
-function displayPartsToString(displayParts) {
-    if (displayParts) {
-        return displayParts.map(displayPart => displayPart.text).join('');
-    }
-    return '';
-}
-//# sourceMappingURL=decorateLanguageService.js.map