@volar/typescript 1.11.1 → 2.0.0-alpha.1

package/lib/node/decorateLanguageService.js

@@ -0,0 +1,662 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateLanguageService = void 0;
+const language_core_1 = require("@volar/language-core");
+const dedupe_1 = require("./dedupe");
+function decorateLanguageService(virtualFiles, languageService, isTsPlugin) {
+    const transformedDiagnostics = new WeakMap();
+    const { findReferences, findRenameLocations, getCompletionEntryDetails, getCompletionsAtPosition, getDefinitionAndBoundSpan, getDefinitionAtPosition, getFileReferences, getImplementationAtPosition, getQuickInfoAtPosition, getReferencesAtPosition, getSemanticDiagnostics, getSyntacticDiagnostics, getSuggestionDiagnostics, getTypeDefinitionAtPosition, getEncodedSemanticClassifications, getDocumentHighlights, getApplicableRefactors, getEditsForRefactor, getRenameInfo, getCodeFixesAtPosition, prepareCallHierarchy, provideCallHierarchyIncomingCalls, provideCallHierarchyOutgoingCalls, provideInlayHints, organizeImports, } = languageService;
+    languageService.prepareCallHierarchy = (fileName, position) => {
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const [generateOffset, mapping] of map.getGeneratedOffsets(position)) {
+                if ((0, language_core_1.isCallHierarchyEnabled)(mapping.data)) {
+                    const item = prepareCallHierarchy(fileName, generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0));
+                    if (Array.isArray(item)) {
+                        return item.map(item => transformCallHierarchyItem(item, language_core_1.isCallHierarchyEnabled));
+                    }
+                    else if (item) {
+                        return transformCallHierarchyItem(item, language_core_1.isCallHierarchyEnabled);
+                    }
+                }
+            }
+        }
+        else {
+            return prepareCallHierarchy(fileName, position);
+        }
+    };
+    languageService.provideCallHierarchyIncomingCalls = (fileName, position) => {
+        let calls = [];
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const [generateOffset, mapping] of map.getGeneratedOffsets(position)) {
+                if ((0, language_core_1.isCallHierarchyEnabled)(mapping.data)) {
+                    calls = provideCallHierarchyIncomingCalls(fileName, generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0));
+                }
+            }
+        }
+        else {
+            calls = provideCallHierarchyIncomingCalls(fileName, position);
+        }
+        return calls
+            .map(call => {
+            const from = transformCallHierarchyItem(call.from, language_core_1.isCallHierarchyEnabled);
+            const fromSpans = call.fromSpans
+                .map(span => transformSpan(call.from.file, span, language_core_1.isCallHierarchyEnabled)?.textSpan)
+                .filter(notEmpty);
+            return {
+                from,
+                fromSpans,
+            };
+        });
+    };
+    languageService.provideCallHierarchyOutgoingCalls = (fileName, position) => {
+        let calls = [];
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const [generateOffset, mapping] of map.getGeneratedOffsets(position)) {
+                if ((0, language_core_1.isCallHierarchyEnabled)(mapping.data)) {
+                    calls = provideCallHierarchyOutgoingCalls(fileName, generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0));
+                }
+            }
+        }
+        else {
+            calls = provideCallHierarchyOutgoingCalls(fileName, position);
+        }
+        return calls
+            .map(call => {
+            const to = transformCallHierarchyItem(call.to, language_core_1.isCallHierarchyEnabled);
+            const fromSpans = call.fromSpans
+                .map(span => transformSpan(fileName, span, language_core_1.isCallHierarchyEnabled)?.textSpan)
+                .filter(notEmpty);
+            return {
+                to,
+                fromSpans,
+            };
+        });
+    };
+    languageService.organizeImports = (args, formatOptions, preferences) => {
+        const unresolved = organizeImports(args, formatOptions, preferences);
+        const resolved = unresolved
+            .map(changes => transformFileTextChanges(changes, language_core_1.isCodeActionsEnabled))
+            .filter(notEmpty);
+        return resolved;
+    };
+    languageService.getQuickInfoAtPosition = (fileName, position) => {
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const [generateOffset, mapping] of map.getGeneratedOffsets(position)) {
+                if ((0, language_core_1.isHoverEnabled)(mapping.data)) {
+                    const result = getQuickInfoAtPosition(fileName, generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0));
+                    if (result) {
+                        const textSpan = transformSpan(fileName, result.textSpan, language_core_1.isHoverEnabled)?.textSpan;
+                        if (textSpan) {
+                            return {
+                                ...result,
+                                textSpan,
+                            };
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            return getQuickInfoAtPosition(fileName, position);
+        }
+    };
+    languageService.getDocumentHighlights = (fileName, position, filesToSearch) => {
+        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isHighlightEnabled, 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 = transformSpan(span.fileName ?? highlights.fileName, span.textSpan, language_core_1.isHighlightEnabled)?.textSpan;
+                    if (textSpan) {
+                        return {
+                            ...span,
+                            contextSpan: transformSpan(span.fileName ?? highlights.fileName, span.contextSpan, language_core_1.isHighlightEnabled)?.textSpan,
+                            textSpan,
+                        };
+                    }
+                })
+                    .filter(notEmpty),
+            };
+        });
+        return resolved;
+    };
+    languageService.getApplicableRefactors = (fileName, positionOrRange, preferences, triggerReason, kind, includeInteractiveActions) => {
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const [generateOffset, mapping] of map.getGeneratedOffsets(typeof positionOrRange === 'number' ? positionOrRange : positionOrRange.pos)) {
+                if ((0, language_core_1.isCodeActionsEnabled)(mapping.data)) {
+                    const por = typeof positionOrRange === 'number'
+                        ? generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0)
+                        : {
+                            pos: generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0),
+                            end: generateOffset + positionOrRange.end - positionOrRange.pos + (isTsPlugin ? sourceFile.snapshot.getLength() : 0),
+                        };
+                    return getApplicableRefactors(fileName, por, preferences, triggerReason, kind, includeInteractiveActions);
+                }
+            }
+            return [];
+        }
+        else {
+            return getApplicableRefactors(fileName, positionOrRange, preferences, triggerReason, kind, includeInteractiveActions);
+        }
+    };
+    languageService.getEditsForRefactor = (fileName, formatOptions, positionOrRange, refactorName, actionName, preferences) => {
+        let edits;
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const [generateOffset, mapping] of map.getGeneratedOffsets(typeof positionOrRange === 'number' ? positionOrRange : positionOrRange.pos)) {
+                if ((0, language_core_1.isCodeActionsEnabled)(mapping.data)) {
+                    const por = typeof positionOrRange === 'number'
+                        ? generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0)
+                        : {
+                            pos: generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0),
+                            end: generateOffset + positionOrRange.end - positionOrRange.pos + (isTsPlugin ? sourceFile.snapshot.getLength() : 0),
+                        };
+                    edits = getEditsForRefactor(fileName, formatOptions, por, refactorName, actionName, preferences);
+                }
+            }
+        }
+        else {
+            edits = getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, preferences);
+        }
+        if (edits) {
+            edits.edits = edits.edits
+                .map(edit => transformFileTextChanges(edit, language_core_1.isCodeActionsEnabled))
+                .filter(notEmpty);
+            return edits;
+        }
+    };
+    languageService.getRenameInfo = (fileName, position, options) => {
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const [generateOffset, mapping] of map.getGeneratedOffsets(position)) {
+                if ((0, language_core_1.isRenameEnabled)(mapping.data)) {
+                    const info = getRenameInfo(fileName, generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0), options);
+                    if (info.canRename) {
+                        const span = transformSpan(fileName, info.triggerSpan, language_core_1.isRenameEnabled);
+                        if (span) {
+                            info.triggerSpan = span.textSpan;
+                            return info;
+                        }
+                    }
+                    else {
+                        return info;
+                    }
+                }
+            }
+            return {
+                canRename: false,
+                localizedErrorMessage: 'Failed to get rename locations',
+            };
+        }
+        else {
+            return getRenameInfo(fileName, position, options);
+        }
+    };
+    languageService.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences) => {
+        let fixes = [];
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const [generateStart, mapping] of map.getGeneratedOffsets(start)) {
+                if ((0, language_core_1.isCodeActionsEnabled)(mapping.data)) {
+                    for (const [generateEnd, mapping] of map.getGeneratedOffsets(end)) {
+                        if ((0, language_core_1.isCodeActionsEnabled)(mapping.data)) {
+                            fixes = getCodeFixesAtPosition(fileName, generateStart + (isTsPlugin ? sourceFile.snapshot.getLength() : 0), generateEnd + (isTsPlugin ? sourceFile.snapshot.getLength() : 0), errorCodes, formatOptions, preferences);
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        else {
+            fixes = getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions, preferences);
+        }
+        fixes = fixes.map(fix => {
+            fix.changes = fix.changes.map(edit => transformFileTextChanges(edit, language_core_1.isCodeActionsEnabled)).filter(notEmpty);
+            return fix;
+        });
+        return fixes;
+    };
+    languageService.getEncodedSemanticClassifications = (fileName, span, format) => {
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            let start;
+            let end;
+            for (const mapping of map.mappings) {
+                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];
+                    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;
+            }
+            if (isTsPlugin) {
+                start += sourceFile.snapshot.getLength();
+                end += sourceFile.snapshot.getLength();
+            }
+            const result = getEncodedSemanticClassifications(fileName, { start, length: end - start }, format);
+            const spans = [];
+            for (let i = 0; i < result.spans.length; i += 3) {
+                for (const [sourceStart, mapping] of map.getSourceOffsets(result.spans[i] - (isTsPlugin ? sourceFile.snapshot.getLength() : 0))) {
+                    if ((0, language_core_1.isSemanticTokensEnabled)(mapping.data)) {
+                        for (const [sourceEnd, mapping] of map.getSourceOffsets(result.spans[i] + result.spans[i + 1] - (isTsPlugin ? sourceFile.snapshot.getLength() : 0))) {
+                            if ((0, language_core_1.isSemanticTokensEnabled)(mapping.data)) {
+                                spans.push(sourceStart, sourceEnd - sourceStart, result.spans[i + 2]);
+                                break;
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+            result.spans = spans;
+            return result;
+        }
+        else {
+            return getEncodedSemanticClassifications(fileName, span);
+        }
+    };
+    languageService.getSyntacticDiagnostics = (fileName) => {
+        return getSyntacticDiagnostics(fileName)
+            .map(diagnostic => transformDiagnostic(diagnostic))
+            .filter(notEmpty);
+    };
+    languageService.getSemanticDiagnostics = (fileName) => {
+        return getSemanticDiagnostics(fileName)
+            .map(diagnostic => transformDiagnostic(diagnostic))
+            .filter(notEmpty);
+    };
+    languageService.getSuggestionDiagnostics = (fileName) => {
+        return getSuggestionDiagnostics(fileName)
+            .map(diagnostic => transformDiagnostic(diagnostic))
+            .filter(notEmpty);
+    };
+    languageService.getDefinitionAndBoundSpan = (fileName, position) => {
+        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isDefinitionEnabled, position => getDefinitionAndBoundSpan(fileName, position), function* (result) {
+            for (const ref of result.definitions ?? []) {
+                yield [ref.fileName, ref.textSpan.start];
+            }
+        });
+        const textSpan = unresolved
+            .map(s => transformSpan(fileName, s.textSpan, language_core_1.isDefinitionEnabled)?.textSpan)
+            .filter(notEmpty)[0];
+        if (!textSpan)
+            return;
+        const definitions = unresolved
+            .map(s => s.definitions
+            ?.map(s => transformDocumentSpan(s, language_core_1.isDefinitionEnabled, s.fileName !== fileName))
+            .filter(notEmpty))
+            .filter(notEmpty)
+            .flat();
+        return {
+            textSpan,
+            definitions: (0, dedupe_1.dedupeDocumentSpans)(definitions),
+        };
+    };
+    languageService.findReferences = (fileName, position) => {
+        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isReferencesEnabled, 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 = transformDocumentSpan(symbol.definition, language_core_1.isDefinitionEnabled);
+            if (definition) {
+                return {
+                    definition,
+                    references: symbol.references
+                        .map(r => transformDocumentSpan(r, language_core_1.isReferencesEnabled))
+                        .filter(notEmpty),
+                };
+            }
+        })
+            .filter(notEmpty);
+        return (0, dedupe_1.dedupeReferencedSymbols)(resolved);
+    };
+    languageService.getDefinitionAtPosition = (fileName, position) => {
+        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isDefinitionEnabled, position => getDefinitionAtPosition(fileName, position), function* (result) {
+            for (const ref of result) {
+                yield [ref.fileName, ref.textSpan.start];
+            }
+        });
+        const resolved = unresolved
+            .flat()
+            .map(s => transformDocumentSpan(s, language_core_1.isDefinitionEnabled, s.fileName !== fileName))
+            .filter(notEmpty);
+        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
+    };
+    languageService.getTypeDefinitionAtPosition = (fileName, position) => {
+        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isTypeDefinitionEnabled, position => getTypeDefinitionAtPosition(fileName, position), function* (result) {
+            for (const ref of result) {
+                yield [ref.fileName, ref.textSpan.start];
+            }
+        });
+        const resolved = unresolved
+            .flat()
+            .map(s => transformDocumentSpan(s, language_core_1.isTypeDefinitionEnabled))
+            .filter(notEmpty);
+        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
+    };
+    languageService.getImplementationAtPosition = (fileName, position) => {
+        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isImplementationEnabled, position => getImplementationAtPosition(fileName, position), function* (result) {
+            for (const ref of result) {
+                yield [ref.fileName, ref.textSpan.start];
+            }
+        });
+        const resolved = unresolved
+            .flat()
+            .map(s => transformDocumentSpan(s, language_core_1.isImplementationEnabled))
+            .filter(notEmpty);
+        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
+    };
+    languageService.findRenameLocations = (fileName, position, findInStrings, findInComments, preferences) => {
+        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isRenameEnabled, 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 => transformDocumentSpan(s, language_core_1.isRenameEnabled))
+            .filter(notEmpty);
+        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
+    };
+    languageService.getReferencesAtPosition = (fileName, position) => {
+        const unresolved = linkedCodeFeatureWorker(fileName, position, language_core_1.isReferencesEnabled, position => getReferencesAtPosition(fileName, position), function* (result) {
+            for (const ref of result) {
+                yield [ref.fileName, ref.textSpan.start];
+            }
+        });
+        const resolved = unresolved
+            .flat()
+            .map(s => transformDocumentSpan(s, language_core_1.isReferencesEnabled))
+            .filter(notEmpty);
+        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
+    };
+    languageService.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const [generateOffset, mapping] of map.getGeneratedOffsets(position)) {
+                if ((0, language_core_1.isCompletionEnabled)(mapping.data)) {
+                    const result = getCompletionsAtPosition(fileName, generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0), options, formattingSettings);
+                    if (result) {
+                        for (const entry of result.entries) {
+                            entry.replacementSpan = transformSpan(fileName, entry.replacementSpan, language_core_1.isCompletionEnabled)?.textSpan;
+                        }
+                        result.optionalReplacementSpan = transformSpan(fileName, result.optionalReplacementSpan, language_core_1.isCompletionEnabled)?.textSpan;
+                    }
+                    return result;
+                }
+            }
+        }
+        else {
+            return getCompletionsAtPosition(fileName, position, options, formattingSettings);
+        }
+    };
+    languageService.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, data) => {
+        const details = getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data);
+        if (details?.codeActions) {
+            for (const codeAction of details.codeActions) {
+                codeAction.changes = codeAction.changes.map(edit => transformFileTextChanges(edit, language_core_1.isCodeLensEnabled)).filter(notEmpty);
+            }
+        }
+        return details;
+    };
+    languageService.provideInlayHints = (fileName, span, preferences) => {
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            let start;
+            let end;
+            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;
+            }
+            if (isTsPlugin) {
+                start += sourceFile.snapshot.getLength();
+                end += sourceFile.snapshot.getLength();
+            }
+            const result = provideInlayHints(fileName, { start, length: end - start }, preferences);
+            const hints = [];
+            for (const hint of result) {
+                for (const [sourcePosition, mapping] of map.getSourceOffsets(hint.position - (isTsPlugin ? sourceFile.snapshot.getLength() : 0))) {
+                    if ((0, language_core_1.isInlayHintsEnabled)(mapping.data)) {
+                        hints.push({
+                            ...hint,
+                            position: sourcePosition,
+                        });
+                        break;
+                    }
+                }
+            }
+            return hints;
+        }
+        else {
+            return provideInlayHints(fileName, span, preferences);
+        }
+    };
+    languageService.getFileReferences = (fileName) => {
+        const unresolved = getFileReferences(fileName);
+        const resolved = unresolved
+            .map(s => transformDocumentSpan(s, language_core_1.isReferencesEnabled))
+            .filter(notEmpty);
+        return (0, dedupe_1.dedupeDocumentSpans)(resolved);
+    };
+    function linkedCodeFeatureWorker(fileName, position, filter, worker, getLinkedCodes) {
+        let results = [];
+        const processedFilePositions = new Set();
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const [generateOffset, mapping] of map.getGeneratedOffsets(position)) {
+                if (filter(mapping.data)) {
+                    process(fileName, generateOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0));
+                }
+            }
+        }
+        else {
+            process(fileName, position);
+        }
+        return results;
+        function process(fileName, position) {
+            if (processedFilePositions.has(fileName + ':' + position))
+                return;
+            processedFilePositions.add(fileName + ':' + position);
+            const result = worker(position);
+            if (!result)
+                return;
+            results = results.concat(result);
+            for (const ref of getLinkedCodes(result)) {
+                processedFilePositions.add(ref[0] + ':' + ref[1]);
+                const [virtualFile, sourceFile] = getVirtualFileAndMap(ref[0]);
+                if (!virtualFile)
+                    continue;
+                const linkedCodeMap = virtualFiles.getLinkedCodeMap(virtualFile);
+                if (!linkedCodeMap)
+                    continue;
+                for (const linkedCodeOffset of linkedCodeMap.getLinkedOffsets(ref[1] - (isTsPlugin ? sourceFile.snapshot.getLength() : 0))) {
+                    process(ref[0], linkedCodeOffset + (isTsPlugin ? sourceFile.snapshot.getLength() : 0));
+                }
+            }
+        }
+    }
+    // transforms
+    function transformCallHierarchyItem(item, filter) {
+        const span = transformSpan(item.file, item.span, filter);
+        const selectionSpan = transformSpan(item.file, item.selectionSpan, filter);
+        return {
+            ...item,
+            span: span?.textSpan ?? { start: 0, length: 0 },
+            selectionSpan: selectionSpan?.textSpan ?? { start: 0, length: 0 },
+        };
+    }
+    function transformDiagnostic(diagnostic) {
+        if (!transformedDiagnostics.has(diagnostic)) {
+            if (diagnostic.start !== undefined && diagnostic.file) {
+                transformedDiagnostics.set(diagnostic, undefined);
+                const [virtualFile, sourceFile, map] = getVirtualFileAndMap(diagnostic.file?.fileName);
+                if (virtualFile) {
+                    for (const [sourceOffset, mapping] of map.getSourceOffsets(diagnostic.start - (isTsPlugin ? sourceFile.snapshot.getLength() : 0))) {
+                        if ((0, language_core_1.shouldReportDiagnostics)(mapping.data)) {
+                            transformedDiagnostics.set(diagnostic, {
+                                ...diagnostic,
+                                start: sourceOffset,
+                            });
+                            break;
+                        }
+                    }
+                }
+                else {
+                    transformedDiagnostics.set(diagnostic, diagnostic);
+                }
+            }
+            else {
+                transformedDiagnostics.set(diagnostic, diagnostic);
+            }
+            if (diagnostic.relatedInformation) {
+                diagnostic.relatedInformation = diagnostic.relatedInformation
+                    .map(transformDiagnostic)
+                    .filter(notEmpty);
+            }
+        }
+        return transformedDiagnostics.get(diagnostic);
+    }
+    function transformFileTextChanges(changes, filter) {
+        const [_, source] = getVirtualFileAndMap(changes.fileName);
+        if (source) {
+            return {
+                ...changes,
+                fileName: source.id,
+                textChanges: changes.textChanges.map(c => {
+                    const span = transformSpan(changes.fileName, c.span, filter);
+                    if (span) {
+                        return {
+                            ...c,
+                            span: span.textSpan,
+                        };
+                    }
+                }).filter(notEmpty),
+            };
+        }
+        else {
+            return changes;
+        }
+    }
+    function transformDocumentSpan(documentSpan, filter, shouldFallback) {
+        let textSpan = transformSpan(documentSpan.fileName, documentSpan.textSpan, filter);
+        if (!textSpan && shouldFallback) {
+            const [virtualFile, source] = getVirtualFileAndMap(documentSpan.fileName);
+            if (virtualFile) {
+                textSpan = {
+                    fileName: source.id,
+                    textSpan: { start: 0, length: 0 },
+                };
+            }
+        }
+        if (!textSpan)
+            return;
+        const contextSpan = transformSpan(documentSpan.fileName, documentSpan.contextSpan, filter);
+        const originalTextSpan = transformSpan(documentSpan.originalFileName, documentSpan.originalTextSpan, filter);
+        const originalContextSpan = transformSpan(documentSpan.originalFileName, documentSpan.originalContextSpan, filter);
+        return {
+            ...documentSpan,
+            fileName: textSpan.fileName,
+            textSpan: textSpan.textSpan,
+            contextSpan: contextSpan?.textSpan,
+            originalFileName: originalTextSpan?.fileName,
+            originalTextSpan: originalTextSpan?.textSpan,
+            originalContextSpan: originalContextSpan?.textSpan,
+        };
+    }
+    function transformSpan(fileName, textSpan, filter) {
+        if (!fileName)
+            return;
+        if (!textSpan)
+            return;
+        const [virtualFile, sourceFile, map] = getVirtualFileAndMap(fileName);
+        if (virtualFile) {
+            for (const sourceStart of map.getSourceOffsets(textSpan.start - (isTsPlugin ? sourceFile.snapshot.getLength() : 0))) {
+                if (filter(sourceStart[1].data)) {
+                    for (const sourceEnd of map.getSourceOffsets(textSpan.start + textSpan.length - (isTsPlugin ? sourceFile.snapshot.getLength() : 0))) {
+                        if (filter(sourceEnd[1].data)) {
+                            return {
+                                fileName: sourceFile.id,
+                                textSpan: {
+                                    start: sourceStart[0],
+                                    length: sourceEnd[0] - sourceStart[0],
+                                },
+                            };
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            return {
+                fileName,
+                textSpan,
+            };
+        }
+    }
+    function getVirtualFileAndMap(fileName) {
+        if (isTsPlugin) {
+            const sourceFile = virtualFiles.getSourceFile(fileName);
+            if (sourceFile?.virtualFile) {
+                for (const virtualFile of (0, language_core_1.forEachEmbeddedFile)(sourceFile.virtualFile[0])) {
+                    const ext = virtualFile.id.substring(fileName.length);
+                    if (virtualFile.typescript && (ext === '.d.ts' || ext.match(/^\.(js|ts)x?$/))) {
+                        for (const map of virtualFiles.getMaps(virtualFile)) {
+                            if (map[1][0] === sourceFile.snapshot) {
+                                return [virtualFile, sourceFile, map[1][1]];
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            const [virtualFile, sourceFile] = virtualFiles.getVirtualFile(fileName);
+            if (virtualFile) {
+                for (const map of virtualFiles.getMaps(virtualFile)) {
+                    if (map[1][0] === sourceFile.snapshot) {
+                        return [virtualFile, sourceFile, map[1][1]];
+                    }
+                }
+            }
+        }
+        return [undefined, undefined, undefined];
+    }
+}
+exports.decorateLanguageService = decorateLanguageService;
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=decorateLanguageService.js.map

package/lib/{serverPlugin.d.ts → node/decorateLanguageServiceHost.d.ts}

@@ -1,9 +1,4 @@
-import { VirtualFiles } from '@volar/language-core';
+import { FileProvider } from '@volar/language-core';
 import type * as ts from 'typescript/lib/tsserverlibrary';
-export declare function decorateLanguageServiceHost(virtualFiles: VirtualFiles, languageServiceHost: ts.LanguageServiceHost, ts: typeof import('typescript/lib/tsserverlibrary'), exts: string[]): void;
+export declare function decorateLanguageServiceHost(virtualFiles: FileProvider, languageServiceHost: ts.LanguageServiceHost, ts: typeof import('typescript/lib/tsserverlibrary'), exts: string[]): void;
 export declare function searchExternalFiles(ts: typeof import('typescript/lib/tsserverlibrary'), project: ts.server.Project, exts: string[]): string[];
-/**
- * @deprecated use `searchExternalFiles` instead
- */
-export declare const getExternalFiles: typeof searchExternalFiles;
-//# sourceMappingURL=serverPlugin.d.ts.map