@volar/typescript 2.2.0-alpha.0 → 2.2.0-alpha.10

package/lib/node/decorateLanguageServiceHost.js

@@ -1,25 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.searchExternalFiles = exports.decorateLanguageServiceHost = void 0;
-const language_core_1 = require("@volar/language-core");
 const resolveModuleName_1 = require("../resolveModuleName");
-function decorateLanguageServiceHost(language, languageServiceHost, ts) {
-    let extraProjectVersion = 0;
-    const exts = language.plugins
+function decorateLanguageServiceHost(ts, language, languageServiceHost) {
+    const extensions = language.plugins
         .map(plugin => plugin.typescript?.extraFileExtensions.map(ext => '.' + ext.extension) ?? [])
         .flat();
     const scripts = new Map();
+    const crashFileNames = new Set();
     const readDirectory = languageServiceHost.readDirectory?.bind(languageServiceHost);
     const resolveModuleNameLiterals = languageServiceHost.resolveModuleNameLiterals?.bind(languageServiceHost);
     const resolveModuleNames = languageServiceHost.resolveModuleNames?.bind(languageServiceHost);
-    const getProjectVersion = languageServiceHost.getProjectVersion?.bind(languageServiceHost);
     const getScriptSnapshot = languageServiceHost.getScriptSnapshot.bind(languageServiceHost);
     const getScriptKind = languageServiceHost.getScriptKind?.bind(languageServiceHost);
     // path completion
     if (readDirectory) {
         languageServiceHost.readDirectory = (path, extensions, exclude, include, depth) => {
             if (extensions) {
-                for (const ext of exts) {
+                for (const ext of extensions) {
                     if (!extensions.includes(ext)) {
                         extensions = [...extensions, ...ext];
                     }
@@ -28,91 +26,88 @@ function decorateLanguageServiceHost(language, languageServiceHost, ts) {
             return readDirectory(path, extensions, exclude, include, depth);
         };
     }
-    if (language.plugins.some(language => language.typescript?.extraFileExtensions.length)) {
+    if (extensions.length) {
         const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, languageServiceHost, language.plugins, fileName => language.scripts.get(fileName));
+        const getCanonicalFileName = languageServiceHost.useCaseSensitiveFileNames?.()
+            ? (fileName) => fileName
+            : (fileName) => fileName.toLowerCase();
+        const moduleResolutionCache = ts.createModuleResolutionCache(languageServiceHost.getCurrentDirectory(), getCanonicalFileName, languageServiceHost.getCompilationSettings());
         if (resolveModuleNameLiterals) {
             languageServiceHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, ...rest) => {
-                if (moduleLiterals.every(name => !exts.some(ext => name.text.endsWith(ext)))) {
+                if (moduleLiterals.every(name => !extensions.some(ext => name.text.endsWith(ext)))) {
                     return resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, ...rest);
                 }
                 return moduleLiterals.map(moduleLiteral => {
-                    return resolveModuleName(moduleLiteral.text, containingFile, options, undefined, redirectedReference);
+                    return resolveModuleName(moduleLiteral.text, containingFile, options, moduleResolutionCache, redirectedReference);
                 });
             };
         }
         if (resolveModuleNames) {
             languageServiceHost.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile) => {
-                if (moduleNames.every(name => !exts.some(ext => name.endsWith(ext)))) {
+                if (moduleNames.every(name => !extensions.some(ext => name.endsWith(ext)))) {
                     return resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile);
                 }
                 return moduleNames.map(moduleName => {
-                    return resolveModuleName(moduleName, containingFile, options, undefined, redirectedReference).resolvedModule;
+                    return resolveModuleName(moduleName, containingFile, options, moduleResolutionCache, redirectedReference).resolvedModule;
                 });
             };
         }
     }
-    if (getProjectVersion) {
-        languageServiceHost.getProjectVersion = () => {
-            return getProjectVersion() + ':' + extraProjectVersion;
-        };
-    }
     languageServiceHost.getScriptSnapshot = fileName => {
-        if (exts.some(ext => fileName.endsWith(ext))) {
-            updateScript(fileName);
-            return scripts.get(fileName)?.snapshot;
+        const virtualScript = updateVirtualScript(fileName);
+        if (virtualScript) {
+            return virtualScript.snapshot;
         }
         return getScriptSnapshot(fileName);
     };
     if (getScriptKind) {
         languageServiceHost.getScriptKind = fileName => {
-            if (exts.some(ext => fileName.endsWith(ext))) {
-                updateScript(fileName);
-                const script = scripts.get(fileName);
-                if (script) {
-                    return script.kind;
-                }
-                return ts.ScriptKind.Deferred;
+            const virtualScript = updateVirtualScript(fileName);
+            if (virtualScript) {
+                return virtualScript.kind;
             }
             return getScriptKind(fileName);
         };
     }
-    function updateScript(fileName) {
-        const version = languageServiceHost.getScriptVersion(fileName);
-        if (version !== scripts.get(fileName)?.version) {
-            let extension = '.ts';
-            let snapshotSnapshot;
-            let scriptKind = ts.ScriptKind.TS;
-            const snapshot = getScriptSnapshot(fileName);
-            if (snapshot) {
-                extraProjectVersion++;
-                const sourceScript = language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
-                if (sourceScript.generated) {
-                    const text = snapshot.getText(0, snapshot.getLength());
-                    let patchedText = text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
-                    const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
-                    if (serviceScript) {
-                        extension = serviceScript.extension;
-                        scriptKind = serviceScript.scriptKind;
-                        patchedText += serviceScript.code.snapshot.getText(0, serviceScript.code.snapshot.getLength());
-                    }
-                    snapshotSnapshot = ts.ScriptSnapshot.fromString(patchedText);
-                    if (sourceScript.generated.languagePlugin.typescript?.getExtraServiceScripts) {
-                        console.warn('getExtraScripts() is not available in this use case.');
-                    }
+    function updateVirtualScript(fileName) {
+        if (crashFileNames.has(fileName)) {
+            return;
+        }
+        let version;
+        try {
+            version = languageServiceHost.getScriptVersion(fileName);
+        }
+        catch {
+            // fix https://github.com/vuejs/language-tools/issues/4278
+            crashFileNames.add(fileName);
+        }
+        if (version === undefined) {
+            // somehow getScriptVersion returns undefined
+            return;
+        }
+        let script = scripts.get(fileName);
+        if (!script || script[0] !== version) {
+            script = [version];
+            const sourceScript = language.scripts.get(fileName);
+            if (sourceScript?.generated) {
+                const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+                if (serviceScript) {
+                    const sourceContents = sourceScript.snapshot.getText(0, sourceScript.snapshot.getLength());
+                    let virtualContents = sourceContents.split('\n').map(line => ' '.repeat(line.length)).join('\n');
+                    virtualContents += serviceScript.code.snapshot.getText(0, serviceScript.code.snapshot.getLength());
+                    script[1] = {
+                        extension: serviceScript.extension,
+                        kind: serviceScript.scriptKind,
+                        snapshot: ts.ScriptSnapshot.fromString(virtualContents),
+                    };
+                }
+                if (sourceScript.generated.languagePlugin.typescript?.getExtraServiceScripts) {
+                    console.warn('getExtraServiceScripts() is not available in TS plugin.');
                 }
             }
-            else if (language.scripts.get(fileName)) {
-                extraProjectVersion++;
-                language.scripts.delete(fileName);
-            }
-            scripts.set(fileName, {
-                version,
-                extension,
-                snapshot: snapshotSnapshot,
-                kind: scriptKind,
-            });
+            scripts.set(fileName, script);
         }
-        return scripts.get(fileName);
+        return script[1];
     }
 }
 exports.decorateLanguageServiceHost = decorateLanguageServiceHost;

package/lib/node/decorateProgram.js

@@ -9,6 +9,7 @@ function decorateProgram(language, program) {
     const getSyntacticDiagnostics = program.getSyntacticDiagnostics;
     const getSemanticDiagnostics = program.getSemanticDiagnostics;
     const getGlobalDiagnostics = program.getGlobalDiagnostics;
+    const getSourceFileByPath = program.getSourceFileByPath;
     // for tsc --noEmit --watch
     // @ts-ignore
     const getBindAndCheckDiagnostics = program.getBindAndCheckDiagnostics;
@@ -17,31 +18,39 @@ function decorateProgram(language, program) {
         return {
             ...result,
             diagnostics: result.diagnostics
-                .map(d => (0, transform_1.transformDiagnostic)(language, d))
+                .map(d => (0, transform_1.transformDiagnostic)(language, d, true))
                 .filter(utils_1.notEmpty),
         };
     };
     program.getSyntacticDiagnostics = (sourceFile, cancellationToken) => {
         return getSyntacticDiagnostics(sourceFile, cancellationToken)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, true))
             .filter(utils_1.notEmpty);
     };
     program.getSemanticDiagnostics = (sourceFile, cancellationToken) => {
         return getSemanticDiagnostics(sourceFile, cancellationToken)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, true))
             .filter(utils_1.notEmpty);
     };
     program.getGlobalDiagnostics = cancellationToken => {
         return getGlobalDiagnostics(cancellationToken)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, true))
             .filter(utils_1.notEmpty);
     };
     // @ts-ignore
     program.getBindAndCheckDiagnostics = (sourceFile, cancellationToken) => {
         return getBindAndCheckDiagnostics(sourceFile, cancellationToken)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, true))
             .filter(utils_1.notEmpty);
     };
+    // fix https://github.com/vuejs/language-tools/issues/4099 with `incremental`
+    program.getSourceFileByPath = path => {
+        const sourceFile = getSourceFileByPath(path);
+        if (sourceFile) {
+            (0, transform_1.fillSourceFileText)(language, sourceFile);
+        }
+        return sourceFile;
+    };
 }
 exports.decorateProgram = decorateProgram;
 //# sourceMappingURL=decorateProgram.js.map

package/lib/node/dedupe.d.ts

@@ -1,3 +1,2 @@
 import type * as ts from 'typescript';
-export declare function dedupeReferencedSymbols<T extends ts.ReferencedSymbol>(items: T[]): T[];
 export declare function dedupeDocumentSpans<T extends ts.DocumentSpan>(items: T[]): T[];

package/lib/node/dedupe.js

@@ -1,14 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dedupeDocumentSpans = exports.dedupeReferencedSymbols = void 0;
-function dedupeReferencedSymbols(items) {
-    return dedupe(items, item => [
-        item.definition.fileName,
-        item.definition.textSpan.start,
-        item.definition.textSpan.length,
-    ].join(':'));
-}
-exports.dedupeReferencedSymbols = dedupeReferencedSymbols;
+exports.dedupeDocumentSpans = void 0;
 function dedupeDocumentSpans(items) {
     return dedupe(items, item => [
         item.fileName,

package/lib/node/proxyCreateProgram.d.ts

@@ -1,3 +1,3 @@
-import type * as ts from 'typescript';
 import { LanguagePlugin } from '@volar/language-core';
-export declare function proxyCreateProgram(ts: typeof import('typescript'), original: typeof ts['createProgram'], extensions: string[], getLanguagePlugins: (ts: typeof import('typescript'), options: ts.CreateProgramOptions) => LanguagePlugin[]): typeof import("typescript").createProgram;
+import type * as ts from 'typescript';
+export declare function proxyCreateProgram(ts: typeof import('typescript'), original: typeof ts['createProgram'], getLanguagePlugins: (ts: typeof import('typescript'), options: ts.CreateProgramOptions) => LanguagePlugin[], getLanguageId: (fileName: string) => string): typeof import("typescript").createProgram;

package/lib/node/proxyCreateProgram.js

@@ -1,117 +1,161 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.proxyCreateProgram = void 0;
-const decorateProgram_1 = require("./decorateProgram");
 const language_core_1 = require("@volar/language-core");
-function proxyCreateProgram(ts, original, extensions, getLanguagePlugins) {
+const resolveModuleName_1 = require("../resolveModuleName");
+const decorateProgram_1 = require("./decorateProgram");
+const arrayEqual = (a, b) => {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+};
+const objectEqual = (a, b) => {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (const key of keysA) {
+        if (a[key] !== b[key]) {
+            return false;
+        }
+    }
+    return true;
+};
+function proxyCreateProgram(ts, original, getLanguagePlugins, getLanguageId) {
+    const sourceFileSnapshots = new Map();
+    const parsedSourceFiles = new WeakMap();
+    let lastOptions;
+    let languagePlugins;
+    let language;
+    let moduleResolutionCache;
     return new Proxy(original, {
         apply: (target, thisArg, args) => {
             const options = args[0];
             assert(!!options.host, '!!options.host');
-            const sourceFileToSnapshotMap = new WeakMap();
-            const language = (0, language_core_1.createLanguage)(getLanguagePlugins(ts, options), ts.sys.useCaseSensitiveFileNames, fileName => {
-                let snapshot;
-                assert(originalSourceFiles.has(fileName), `originalSourceFiles.has(${fileName})`);
-                const sourceFile = originalSourceFiles.get(fileName);
-                if (sourceFile) {
-                    snapshot = sourceFileToSnapshotMap.get(sourceFile);
-                    if (!snapshot) {
-                        snapshot = {
-                            getChangeRange() {
-                                return undefined;
-                            },
-                            getLength() {
-                                return sourceFile.text.length;
-                            },
-                            getText(start, end) {
-                                return sourceFile.text.substring(start, end);
-                            },
-                        };
-                        sourceFileToSnapshotMap.set(sourceFile, snapshot);
-                    }
-                }
-                if (snapshot) {
-                    language.scripts.set(fileName, (0, language_core_1.resolveCommonLanguageId)(fileName), snapshot);
-                }
-                else {
-                    language.scripts.delete(fileName);
-                }
-            });
-            const originalSourceFiles = new Map();
-            const parsedSourceFiles = new WeakMap();
-            const arbitraryExtensions = extensions.map(ext => `.d${ext}.ts`);
-            const originalHost = options.host;
-            const moduleResolutionHost = {
-                ...originalHost,
-                fileExists(fileName) {
-                    for (let i = 0; i < arbitraryExtensions.length; i++) {
-                        if (fileName.endsWith(arbitraryExtensions[i])) {
-                            return originalHost.fileExists(fileName.slice(0, -arbitraryExtensions[i].length) + extensions[i]);
+            if (!lastOptions
+                || !languagePlugins
+                || !language
+                || !arrayEqual(options.rootNames, lastOptions.rootNames)
+                || !objectEqual(options.options, lastOptions.options)) {
+                moduleResolutionCache = ts.createModuleResolutionCache(options.host.getCurrentDirectory(), options.host.getCanonicalFileName, options.options);
+                lastOptions = options;
+                languagePlugins = getLanguagePlugins(ts, options);
+                language = (0, language_core_1.createLanguage)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
+                    if (!sourceFileSnapshots.has(fileName)) {
+                        const sourceFileText = originalHost.readFile(fileName);
+                        if (sourceFileText !== undefined) {
+                            sourceFileSnapshots.set(fileName, [undefined, {
+                                    getChangeRange() {
+                                        return undefined;
+                                    },
+                                    getLength() {
+                                        return sourceFileText.length;
+                                    },
+                                    getText(start, end) {
+                                        return sourceFileText.substring(start, end);
+                                    },
+                                }]);
+                        }
+                        else {
+                            sourceFileSnapshots.set(fileName, [undefined, undefined]);
                         }
                     }
-                    return originalHost.fileExists(fileName);
-                },
-            };
+                    const snapshot = sourceFileSnapshots.get(fileName)?.[1];
+                    if (snapshot) {
+                        language.scripts.set(fileName, getLanguageId(fileName), snapshot);
+                    }
+                    else {
+                        language.scripts.delete(fileName);
+                    }
+                });
+            }
+            const originalHost = options.host;
+            const extensions = languagePlugins
+                .map(plugin => plugin.typescript?.extraFileExtensions.map(({ extension }) => `.${extension}`) ?? [])
+                .flat();
             options.host = { ...originalHost };
-            options.options.allowArbitraryExtensions = true;
             options.host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
                 const originalSourceFile = originalHost.getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
-                originalSourceFiles.set(fileName, originalSourceFile);
-                if (originalSourceFile && extensions.some(ext => fileName.endsWith(ext))) {
-                    let sourceFile2 = parsedSourceFiles.get(originalSourceFile);
-                    if (!sourceFile2) {
-                        const sourceScript = language.scripts.get(fileName);
-                        assert(!!sourceScript, '!!sourceScript');
-                        let patchedText = originalSourceFile.text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
-                        let scriptKind = ts.ScriptKind.TS;
-                        if (sourceScript.generated?.languagePlugin.typescript) {
-                            const { getServiceScript: getScript, getExtraServiceScripts: getExtraScripts } = sourceScript.generated.languagePlugin.typescript;
-                            const serviceScript = getScript(sourceScript.generated.root);
-                            if (serviceScript) {
-                                scriptKind = serviceScript.scriptKind;
-                                patchedText += serviceScript.code.snapshot.getText(0, serviceScript.code.snapshot.getLength());
-                            }
-                            if (getExtraScripts) {
-                                console.warn('getExtraScripts() is not available in this use case.');
-                            }
+                if (!sourceFileSnapshots.has(fileName)
+                    || sourceFileSnapshots.get(fileName)?.[0] !== originalSourceFile) {
+                    if (originalSourceFile) {
+                        sourceFileSnapshots.set(fileName, [originalSourceFile, {
+                                getChangeRange() {
+                                    return undefined;
+                                },
+                                getLength() {
+                                    return originalSourceFile.text.length;
+                                },
+                                getText(start, end) {
+                                    return originalSourceFile.text.substring(start, end);
+                                },
+                            }]);
+                    }
+                    else {
+                        sourceFileSnapshots.set(fileName, [undefined, undefined]);
+                    }
+                }
+                if (!originalSourceFile) {
+                    return;
+                }
+                if (!parsedSourceFiles.has(originalSourceFile)) {
+                    const sourceScript = language.scripts.get(fileName);
+                    assert(!!sourceScript, '!!sourceScript');
+                    parsedSourceFiles.set(originalSourceFile, originalSourceFile);
+                    if (sourceScript.generated?.languagePlugin.typescript) {
+                        const { getServiceScript, getExtraServiceScripts } = sourceScript.generated.languagePlugin.typescript;
+                        const serviceScript = getServiceScript(sourceScript.generated.root);
+                        if (serviceScript) {
+                            let patchedText = originalSourceFile.text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
+                            let scriptKind = ts.ScriptKind.TS;
+                            scriptKind = serviceScript.scriptKind;
+                            patchedText += serviceScript.code.snapshot.getText(0, serviceScript.code.snapshot.getLength());
+                            const parsedSourceFile = ts.createSourceFile(fileName, patchedText, languageVersionOrOptions, undefined, scriptKind);
+                            // @ts-expect-error
+                            parsedSourceFile.version = originalSourceFile.version;
+                            parsedSourceFiles.set(originalSourceFile, parsedSourceFile);
+                        }
+                        if (getExtraServiceScripts) {
+                            console.warn('getExtraServiceScripts() is not available in this use case.');
                         }
-                        sourceFile2 = ts.createSourceFile(fileName, patchedText, 99, true, scriptKind);
-                        // @ts-expect-error
-                        sourceFile2.version = originalSourceFile.version;
-                        parsedSourceFiles.set(originalSourceFile, sourceFile2);
                     }
-                    return sourceFile2;
                 }
-                return originalSourceFile;
-            };
-            options.host.resolveModuleNameLiterals = (moduleNames, containingFile, redirectedReference, options) => {
-                return moduleNames.map(name => {
-                    return resolveModuleName(name.text, containingFile, options, redirectedReference);
-                });
+                return parsedSourceFiles.get(originalSourceFile);
             };
-            options.host.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options) => {
-                return moduleNames.map(name => {
-                    return resolveModuleName(name, containingFile, options, redirectedReference).resolvedModule;
-                });
-            };
-            const program = Reflect.apply(target, thisArg, [options]);
+            if (extensions.length) {
+                options.options.allowArbitraryExtensions = true;
+                const resolveModuleName = (0, resolveModuleName_1.createResolveModuleName)(ts, originalHost, language.plugins, fileName => language.scripts.get(fileName));
+                const resolveModuleNameLiterals = originalHost.resolveModuleNameLiterals;
+                const resolveModuleNames = originalHost.resolveModuleNames;
+                options.host.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, compilerOptions, ...rest) => {
+                    if (resolveModuleNameLiterals && moduleLiterals.every(name => !extensions.some(ext => name.text.endsWith(ext)))) {
+                        return resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, compilerOptions, ...rest);
+                    }
+                    return moduleLiterals.map(moduleLiteral => {
+                        return resolveModuleName(moduleLiteral.text, containingFile, compilerOptions, moduleResolutionCache, redirectedReference);
+                    });
+                };
+                options.host.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile) => {
+                    if (resolveModuleNames && moduleNames.every(name => !extensions.some(ext => name.endsWith(ext)))) {
+                        return resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, compilerOptions, containingSourceFile);
+                    }
+                    return moduleNames.map(moduleName => {
+                        return resolveModuleName(moduleName, containingFile, compilerOptions, moduleResolutionCache, redirectedReference).resolvedModule;
+                    });
+                };
+            }
+            const program = Reflect.apply(target, thisArg, args);
             (0, decorateProgram_1.decorateProgram)(language, program);
             // TODO: #128
-            program.__volar__ = { files: language };
+            program.__volar__ = { language };
             return program;
-            function resolveModuleName(name, containingFile, options, redirectedReference) {
-                const resolved = ts.resolveModuleName(name, containingFile, options, moduleResolutionHost, originalHost.getModuleResolutionCache?.(), redirectedReference);
-                if (resolved.resolvedModule) {
-                    for (let i = 0; i < arbitraryExtensions.length; i++) {
-                        if (resolved.resolvedModule.resolvedFileName.endsWith(arbitraryExtensions[i])) {
-                            const sourceFileName = resolved.resolvedModule.resolvedFileName.slice(0, -arbitraryExtensions[i].length) + extensions[i];
-                            resolved.resolvedModule.resolvedFileName = sourceFileName;
-                            resolved.resolvedModule.extension = extensions[i];
-                        }
-                    }
-                }
-                return resolved;
-            }
         },
     });
 }

package/lib/node/transform.d.ts

@@ -1,10 +1,15 @@
-import { Language, CodeInformation } from '@volar/language-core';
+import { Language, CodeInformation, SourceMap, SourceScript } from '@volar/language-core';
 import type * as ts from 'typescript';
-export declare function transformCallHierarchyItem(files: Language, item: ts.CallHierarchyItem, filter: (data: CodeInformation) => boolean): ts.CallHierarchyItem;
-export declare function transformDiagnostic<T extends ts.Diagnostic>(files: Language, diagnostic: T): T | undefined;
-export declare function transformFileTextChanges(files: Language, changes: ts.FileTextChanges, filter: (data: CodeInformation) => boolean): ts.FileTextChanges | undefined;
-export declare function transformDocumentSpan<T extends ts.DocumentSpan>(files: Language, documentSpan: T, filter: (data: CodeInformation) => boolean, shouldFallback?: boolean): T | undefined;
-export declare function transformSpan(files: Language, fileName: string | undefined, textSpan: ts.TextSpan | undefined, filter: (data: CodeInformation) => boolean): {
+export declare function transformCallHierarchyItem(language: Language, item: ts.CallHierarchyItem, filter: (data: CodeInformation) => boolean): ts.CallHierarchyItem;
+export declare function transformDiagnostic<T extends ts.Diagnostic>(language: Language, diagnostic: T, isTsc: boolean): T | undefined;
+export declare function fillSourceFileText(language: Language, sourceFile: ts.SourceFile): void;
+export declare function transformFileTextChanges(language: Language, changes: ts.FileTextChanges, filter: (data: CodeInformation) => boolean): ts.FileTextChanges | undefined;
+export declare function transformDocumentSpan<T extends ts.DocumentSpan>(language: Language, documentSpan: T, filter: (data: CodeInformation) => boolean, shouldFallback?: boolean): T | undefined;
+export declare function transformSpan(language: Language, fileName: string | undefined, textSpan: ts.TextSpan | undefined, filter: (data: CodeInformation) => boolean): {
     fileName: string;
     textSpan: ts.TextSpan;
 } | undefined;
+export declare function transformTextChange(sourceScript: SourceScript, map: SourceMap<CodeInformation>, textChange: ts.TextChange, filter: (data: CodeInformation) => boolean): ts.TextChange | undefined;
+export declare function transformTextSpan(sourceScript: SourceScript, map: SourceMap<CodeInformation>, textSpan: ts.TextSpan, filter: (data: CodeInformation) => boolean): ts.TextSpan | undefined;
+export declare function toSourceOffset(sourceScript: SourceScript, map: SourceMap, position: number, filter: (data: CodeInformation) => boolean): number | undefined;
+export declare function toGeneratedOffset(sourceScript: SourceScript, map: SourceMap, position: number, filter: (data: CodeInformation) => boolean): number | undefined;