@volar/typescript 2.2.0-alpha.8 → 2.2.0

package/lib/common.d.ts

@@ -0,0 +1,2 @@
+import type { LanguagePlugin } from "@volar/language-core";
+export declare const fileLanguageIdProviderPlugin: LanguagePlugin;

package/lib/common.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileLanguageIdProviderPlugin = void 0;
+exports.fileLanguageIdProviderPlugin = {
+    getLanguageId(scriptId) {
+        const ext = scriptId.split('.').pop();
+        switch (ext) {
+            case 'js': return 'javascript';
+            case 'cjs': return 'javascript';
+            case 'mjs': return 'javascript';
+            case 'ts': return 'typescript';
+            case 'cts': return 'typescript';
+            case 'mts': return 'typescript';
+            case 'jsx': return 'javascriptreact';
+            case 'tsx': return 'typescriptreact';
+            case 'json': return 'json';
+        }
+    },
+};
+//# sourceMappingURL=common.js.map

package/lib/node/decorateLanguageService.js

@@ -5,10 +5,12 @@ const language_core_1 = require("@volar/language-core");
 const dedupe_1 = require("./dedupe");
 const utils_1 = require("./utils");
 const transform_1 = require("./transform");
+const windowsPathReg = /\\/g;
 function decorateLanguageService(language, languageService) {
     // ignored methods
     const { getNavigationTree, getOutliningSpans, } = languageService;
-    languageService.getNavigationTree = fileName => {
+    languageService.getNavigationTree = filePath => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const tree = getNavigationTree(fileName);
@@ -19,7 +21,8 @@ function decorateLanguageService(language, languageService) {
             return getNavigationTree(fileName);
         }
     };
-    languageService.getOutliningSpans = fileName => {
+    languageService.getOutliningSpans = filePath => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             return [];
@@ -29,8 +32,9 @@ function decorateLanguageService(language, languageService) {
         }
     };
     // methods
-    const { findReferences, findRenameLocations, getCompletionEntryDetails, getCompletionsAtPosition, getDefinitionAndBoundSpan, getDefinitionAtPosition, getFileReferences, getFormattingEditsForDocument, getFormattingEditsForRange, getFormattingEditsAfterKeystroke, getImplementationAtPosition, getLinkedEditingRangeAtPosition, getQuickInfoAtPosition, getReferencesAtPosition, getSemanticDiagnostics, getSyntacticDiagnostics, getSuggestionDiagnostics, getTypeDefinitionAtPosition, getEncodedSemanticClassifications, getDocumentHighlights, getApplicableRefactors, getEditsForFileRename, getEditsForRefactor, getRenameInfo, getCodeFixesAtPosition, prepareCallHierarchy, provideCallHierarchyIncomingCalls, provideCallHierarchyOutgoingCalls, provideInlayHints, organizeImports, } = languageService;
-    languageService.getFormattingEditsForDocument = (fileName, options) => {
+    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, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             if (!map.mappings.some(mapping => (0, language_core_1.isFormattingEnabled)(mapping.data))) {
@@ -45,7 +49,8 @@ function decorateLanguageService(language, languageService) {
             return getFormattingEditsForDocument(fileName, options);
         }
     };
-    languageService.getFormattingEditsForRange = (fileName, start, end, options) => {
+    languageService.getFormattingEditsForRange = (filePath, start, end, options) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generateStart = (0, transform_1.toGeneratedOffset)(sourceScript, map, start, language_core_1.isFormattingEnabled);
@@ -62,7 +67,8 @@ function decorateLanguageService(language, languageService) {
             return getFormattingEditsForRange(fileName, start, end, options);
         }
     };
-    languageService.getFormattingEditsAfterKeystroke = (fileName, position, key, options) => {
+    languageService.getFormattingEditsAfterKeystroke = (filePath, position, key, options) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, position, language_core_1.isFormattingEnabled);
@@ -84,7 +90,8 @@ function decorateLanguageService(language, languageService) {
             .map(edit => (0, transform_1.transformFileTextChanges)(language, edit, language_core_1.isRenameEnabled))
             .filter(utils_1.notEmpty);
     };
-    languageService.getLinkedEditingRangeAtPosition = (fileName, position) => {
+    languageService.getLinkedEditingRangeAtPosition = (filePath, position) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, position, language_core_1.isLinkedEditingEnabled);
@@ -104,7 +111,8 @@ function decorateLanguageService(language, languageService) {
             return getLinkedEditingRangeAtPosition(fileName, position);
         }
     };
-    languageService.prepareCallHierarchy = (fileName, position) => {
+    languageService.prepareCallHierarchy = (filePath, position) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, position, language_core_1.isCallHierarchyEnabled);
@@ -122,8 +130,9 @@ function decorateLanguageService(language, languageService) {
             return prepareCallHierarchy(fileName, position);
         }
     };
-    languageService.provideCallHierarchyIncomingCalls = (fileName, position) => {
+    languageService.provideCallHierarchyIncomingCalls = (filePath, position) => {
         let calls = [];
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, position, language_core_1.isCallHierarchyEnabled);
@@ -146,8 +155,9 @@ function decorateLanguageService(language, languageService) {
             };
         });
     };
-    languageService.provideCallHierarchyOutgoingCalls = (fileName, position) => {
+    languageService.provideCallHierarchyOutgoingCalls = (filePath, position) => {
         let calls = [];
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, position, language_core_1.isCallHierarchyEnabled);
@@ -179,7 +189,8 @@ function decorateLanguageService(language, languageService) {
             .filter(utils_1.notEmpty);
         return resolved;
     };
-    languageService.getQuickInfoAtPosition = (fileName, position) => {
+    languageService.getQuickInfoAtPosition = (filePath, position) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, position, language_core_1.isHoverEnabled);
@@ -200,7 +211,30 @@ function decorateLanguageService(language, languageService) {
             return getQuickInfoAtPosition(fileName, position);
         }
     };
-    languageService.getDocumentHighlights = (fileName, position, filesToSearch) => {
+    languageService.getSignatureHelpItems = (filePath, position, options) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
+        const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
+        if (serviceScript) {
+            const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, position, language_core_1.isSignatureHelpEnabled);
+            if (generatePosition !== undefined) {
+                const result = getSignatureHelpItems(fileName, generatePosition, options);
+                if (result) {
+                    const applicableSpan = (0, transform_1.transformTextSpan)(sourceScript, map, result.applicableSpan, language_core_1.isSignatureHelpEnabled);
+                    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, position => getDocumentHighlights(fileName, position, filesToSearch), function* (result) {
             for (const ref of result) {
                 for (const reference of ref.highlightSpans) {
@@ -229,7 +263,8 @@ function decorateLanguageService(language, languageService) {
         });
         return resolved;
     };
-    languageService.getApplicableRefactors = (fileName, positionOrRange, preferences, triggerReason, kind, includeInteractiveActions) => {
+    languageService.getApplicableRefactors = (filePath, positionOrRange, preferences, triggerReason, kind, includeInteractiveActions) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, typeof positionOrRange === 'number' ? positionOrRange : positionOrRange.pos, language_core_1.isCodeActionsEnabled);
@@ -248,8 +283,9 @@ function decorateLanguageService(language, languageService) {
             return getApplicableRefactors(fileName, positionOrRange, preferences, triggerReason, kind, includeInteractiveActions);
         }
     };
-    languageService.getEditsForRefactor = (fileName, formatOptions, positionOrRange, refactorName, actionName, preferences) => {
+    languageService.getEditsForRefactor = (filePath, formatOptions, positionOrRange, refactorName, actionName, preferences) => {
         let edits;
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, typeof positionOrRange === 'number'
@@ -275,12 +311,13 @@ function decorateLanguageService(language, languageService) {
             return edits;
         }
     };
-    languageService.getRenameInfo = (fileName, position, options) => {
+    languageService.getRenameInfo = (filePath, position, options) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
-            const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, position, language_core_1.isRenameEnabled);
-            if (generatePosition !== undefined) {
-                const info = getRenameInfo(fileName, generatePosition, options);
+            let failed;
+            for (const generateOffset of (0, transform_1.forEachGeneratedOffset)(sourceScript, map, position, language_core_1.isRenameEnabled)) {
+                const info = getRenameInfo(fileName, generateOffset, options);
                 if (info.canRename) {
                     const span = (0, transform_1.transformTextSpan)(sourceScript, map, info.triggerSpan, language_core_1.isRenameEnabled);
                     if (span) {
@@ -289,9 +326,12 @@ function decorateLanguageService(language, languageService) {
                     }
                 }
                 else {
-                    return info;
+                    failed = info;
                 }
             }
+            if (failed) {
+                return failed;
+            }
             return {
                 canRename: false,
                 localizedErrorMessage: 'Failed to get rename locations',
@@ -301,8 +341,9 @@ function decorateLanguageService(language, languageService) {
             return getRenameInfo(fileName, position, options);
         }
     };
-    languageService.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences) => {
+    languageService.getCodeFixesAtPosition = (filePath, start, end, errorCodes, formatOptions, preferences) => {
         let fixes = [];
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generateStart = (0, transform_1.toGeneratedOffset)(sourceScript, map, start, language_core_1.isCodeActionsEnabled);
@@ -320,7 +361,8 @@ function decorateLanguageService(language, languageService) {
         });
         return fixes;
     };
-    languageService.getEncodedSemanticClassifications = (fileName, span, format) => {
+    languageService.getEncodedSemanticClassifications = (filePath, span, format) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             let start;
@@ -354,22 +396,26 @@ function decorateLanguageService(language, languageService) {
             return getEncodedSemanticClassifications(fileName, span, format);
         }
     };
-    languageService.getSyntacticDiagnostics = fileName => {
+    languageService.getSyntacticDiagnostics = filePath => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         return getSyntacticDiagnostics(fileName)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, false))
             .filter(utils_1.notEmpty);
     };
-    languageService.getSemanticDiagnostics = fileName => {
+    languageService.getSemanticDiagnostics = filePath => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         return getSemanticDiagnostics(fileName)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, false))
             .filter(utils_1.notEmpty);
     };
-    languageService.getSuggestionDiagnostics = fileName => {
+    languageService.getSuggestionDiagnostics = filePath => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         return getSuggestionDiagnostics(fileName)
-            .map(d => (0, transform_1.transformDiagnostic)(language, d))
+            .map(d => (0, transform_1.transformDiagnostic)(language, d, false))
             .filter(utils_1.notEmpty);
     };
-    languageService.getDefinitionAndBoundSpan = (fileName, position) => {
+    languageService.getDefinitionAndBoundSpan = (filePath, position) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         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];
@@ -392,7 +438,8 @@ function decorateLanguageService(language, languageService) {
             definitions: (0, dedupe_1.dedupeDocumentSpans)(definitions),
         };
     };
-    languageService.findReferences = (fileName, position) => {
+    languageService.findReferences = (filePath, position) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         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) {
@@ -403,20 +450,18 @@ function decorateLanguageService(language, languageService) {
         const resolved = unresolved
             .flat()
             .map(symbol => {
-            const definition = (0, transform_1.transformDocumentSpan)(language, symbol.definition, language_core_1.isDefinitionEnabled);
-            if (definition) {
-                return {
-                    definition,
-                    references: symbol.references
-                        .map(r => (0, transform_1.transformDocumentSpan)(language, r, language_core_1.isReferencesEnabled))
-                        .filter(utils_1.notEmpty),
-                };
-            }
-        })
-            .filter(utils_1.notEmpty);
-        return (0, dedupe_1.dedupeReferencedSymbols)(resolved);
+            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(utils_1.notEmpty),
+            };
+        });
+        return resolved;
     };
-    languageService.getDefinitionAtPosition = (fileName, position) => {
+    languageService.getDefinitionAtPosition = (filePath, position) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         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];
@@ -428,7 +473,8 @@ function decorateLanguageService(language, languageService) {
             .filter(utils_1.notEmpty);
         return (0, dedupe_1.dedupeDocumentSpans)(resolved);
     };
-    languageService.getTypeDefinitionAtPosition = (fileName, position) => {
+    languageService.getTypeDefinitionAtPosition = (filePath, position) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         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];
@@ -440,7 +486,8 @@ function decorateLanguageService(language, languageService) {
             .filter(utils_1.notEmpty);
         return (0, dedupe_1.dedupeDocumentSpans)(resolved);
     };
-    languageService.getImplementationAtPosition = (fileName, position) => {
+    languageService.getImplementationAtPosition = (filePath, position) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         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];
@@ -452,7 +499,8 @@ function decorateLanguageService(language, languageService) {
             .filter(utils_1.notEmpty);
         return (0, dedupe_1.dedupeDocumentSpans)(resolved);
     };
-    languageService.findRenameLocations = (fileName, position, findInStrings, findInComments, preferences) => {
+    languageService.findRenameLocations = (filePath, position, findInStrings, findInComments, preferences) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         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];
@@ -464,7 +512,8 @@ function decorateLanguageService(language, languageService) {
             .filter(utils_1.notEmpty);
         return (0, dedupe_1.dedupeDocumentSpans)(resolved);
     };
-    languageService.getReferencesAtPosition = (fileName, position) => {
+    languageService.getReferencesAtPosition = (filePath, position) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         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];
@@ -476,7 +525,8 @@ function decorateLanguageService(language, languageService) {
             .filter(utils_1.notEmpty);
         return (0, dedupe_1.dedupeDocumentSpans)(resolved);
     };
-    languageService.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
+    languageService.getCompletionsAtPosition = (filePath, position, options, formattingSettings) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             let mainResult;
@@ -524,8 +574,9 @@ function decorateLanguageService(language, languageService) {
             return getCompletionsAtPosition(fileName, position, options, formattingSettings);
         }
     };
-    languageService.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, data) => {
+    languageService.getCompletionEntryDetails = (filePath, position, entryName, formatOptions, source, preferences, data) => {
         let details;
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             const generatePosition = (0, transform_1.toGeneratedOffset)(sourceScript, map, position, language_core_1.isCompletionEnabled);
@@ -543,7 +594,8 @@ function decorateLanguageService(language, languageService) {
         }
         return details;
     };
-    languageService.provideInlayHints = (fileName, span, preferences) => {
+    languageService.provideInlayHints = (filePath, span, preferences) => {
+        const fileName = filePath.replace(windowsPathReg, '/');
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
             let start;
@@ -579,7 +631,8 @@ function decorateLanguageService(language, languageService) {
             return provideInlayHints(fileName, span, preferences);
         }
     };
-    languageService.getFileReferences = fileName => {
+    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))
@@ -587,7 +640,7 @@ function decorateLanguageService(language, languageService) {
         return (0, dedupe_1.dedupeDocumentSpans)(resolved);
     };
     function linkedCodeFeatureWorker(fileName, position, filter, worker, getLinkedCodes) {
-        let results = [];
+        const results = [];
         const processedFilePositions = new Set();
         const [serviceScript, sourceScript, map] = (0, utils_1.getServiceScript)(language, fileName);
         if (serviceScript) {
@@ -610,7 +663,7 @@ function decorateLanguageService(language, languageService) {
             if (!result) {
                 return;
             }
-            results = results.concat(result);
+            results.push(result);
             for (const ref of getLinkedCodes(result)) {
                 processedFilePositions.add(ref[0] + ':' + ref[1]);
                 const [virtualFile, sourceScript] = (0, utils_1.getServiceScript)(language, ref[0]);

package/lib/node/decorateLanguageServiceHost.js

@@ -7,6 +7,7 @@ function decorateLanguageServiceHost(ts, language, languageServiceHost) {
         .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);
@@ -69,8 +70,19 @@ function decorateLanguageServiceHost(ts, language, languageServiceHost) {
         };
     }
     function updateVirtualScript(fileName) {
-        const version = languageServiceHost.getScriptVersion(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);

package/lib/node/decorateProgram.js

@@ -18,29 +18,29 @@ 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`

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 { LanguagePlugin } from '@volar/language-core';
 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;
+export declare function proxyCreateProgram(ts: typeof import('typescript'), original: typeof ts['createProgram'], getLanguagePlugins: (ts: typeof import('typescript'), options: ts.CreateProgramOptions) => LanguagePlugin[]): typeof import("typescript").createProgram;

package/lib/node/proxyCreateProgram.js

@@ -4,6 +4,7 @@ exports.proxyCreateProgram = void 0;
 const language_core_1 = require("@volar/language-core");
 const resolveModuleName_1 = require("../resolveModuleName");
 const decorateProgram_1 = require("./decorateProgram");
+const common_1 = require("../common");
 const arrayEqual = (a, b) => {
     if (a.length !== b.length) {
         return false;
@@ -28,7 +29,7 @@ const objectEqual = (a, b) => {
     }
     return true;
 };
-function proxyCreateProgram(ts, original, getLanguagePlugins, getLanguageId) {
+function proxyCreateProgram(ts, original, getLanguagePlugins) {
     const sourceFileSnapshots = new Map();
     const parsedSourceFiles = new WeakMap();
     let lastOptions;
@@ -47,7 +48,10 @@ function proxyCreateProgram(ts, original, getLanguagePlugins, getLanguageId) {
                 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 => {
+                language = (0, language_core_1.createLanguage)([
+                    ...languagePlugins,
+                    common_1.fileLanguageIdProviderPlugin,
+                ], ts.sys.useCaseSensitiveFileNames, fileName => {
                     if (!sourceFileSnapshots.has(fileName)) {
                         const sourceFileText = originalHost.readFile(fileName);
                         if (sourceFileText !== undefined) {
@@ -69,7 +73,7 @@ function proxyCreateProgram(ts, original, getLanguagePlugins, getLanguageId) {
                     }
                     const snapshot = sourceFileSnapshots.get(fileName)?.[1];
                     if (snapshot) {
-                        language.scripts.set(fileName, getLanguageId(fileName), snapshot);
+                        language.scripts.set(fileName, snapshot);
                     }
                     else {
                         language.scripts.delete(fileName);

package/lib/node/transform.d.ts

@@ -1,7 +1,7 @@
 import { Language, CodeInformation, SourceMap, SourceScript } from '@volar/language-core';
 import type * as ts from 'typescript';
 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): T | undefined;
+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;
@@ -13,3 +13,4 @@ export declare function transformTextChange(sourceScript: SourceScript, map: Sou
 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;
+export declare function forEachGeneratedOffset(sourceScript: SourceScript, map: SourceMap, position: number, filter: (data: CodeInformation) => boolean): Generator<number, void, unknown>;

package/lib/node/transform.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toGeneratedOffset = exports.toSourceOffset = exports.transformTextSpan = exports.transformTextChange = exports.transformSpan = exports.transformDocumentSpan = exports.transformFileTextChanges = exports.fillSourceFileText = exports.transformDiagnostic = exports.transformCallHierarchyItem = void 0;
+exports.forEachGeneratedOffset = exports.toGeneratedOffset = exports.toSourceOffset = exports.transformTextSpan = exports.transformTextChange = exports.transformSpan = exports.transformDocumentSpan = exports.transformFileTextChanges = exports.fillSourceFileText = exports.transformDiagnostic = exports.transformCallHierarchyItem = void 0;
 const language_core_1 = require("@volar/language-core");
 const utils_1 = require("./utils");
 const transformedDiagnostics = new WeakMap();
@@ -15,13 +15,13 @@ function transformCallHierarchyItem(language, item, filter) {
     };
 }
 exports.transformCallHierarchyItem = transformCallHierarchyItem;
-function transformDiagnostic(language, diagnostic) {
+function transformDiagnostic(language, diagnostic, isTsc) {
     if (!transformedDiagnostics.has(diagnostic)) {
         transformedDiagnostics.set(diagnostic, undefined);
         const { relatedInformation } = diagnostic;
         if (relatedInformation) {
             diagnostic.relatedInformation = relatedInformation
-                .map(d => transformDiagnostic(language, d))
+                .map(d => transformDiagnostic(language, d, isTsc))
                 .filter(utils_1.notEmpty);
         }
         if (diagnostic.file !== undefined
@@ -31,7 +31,9 @@ function transformDiagnostic(language, diagnostic) {
             if (serviceScript) {
                 const sourceSpan = transformTextSpan(sourceScript, map, { start: diagnostic.start, length: diagnostic.length }, language_core_1.shouldReportDiagnostics);
                 if (sourceSpan) {
-                    fillSourceFileText(language, diagnostic.file);
+                    if (isTsc) {
+                        fillSourceFileText(language, diagnostic.file);
+                    }
                     transformedDiagnostics.set(diagnostic, {
                         ...diagnostic,
                         start: sourceSpan.start,
@@ -61,7 +63,6 @@ function fillSourceFileText(language, sourceFile) {
         sourceFile.text = sourceScript.snapshot.getText(0, sourceScript.snapshot.getLength())
             + sourceFile.text.substring(sourceScript.snapshot.getLength());
     }
-    return;
 }
 exports.fillSourceFileText = fillSourceFileText;
 function transformFileTextChanges(language, changes, filter) {
@@ -88,13 +89,10 @@ exports.transformFileTextChanges = transformFileTextChanges;
 function transformDocumentSpan(language, documentSpan, filter, shouldFallback) {
     let textSpan = transformSpan(language, documentSpan.fileName, documentSpan.textSpan, filter);
     if (!textSpan && shouldFallback) {
-        const [serviceScript] = (0, utils_1.getServiceScript)(language, documentSpan.fileName);
-        if (serviceScript) {
-            textSpan = {
-                fileName: documentSpan.fileName,
-                textSpan: { start: 0, length: 0 },
-            };
-        }
+        textSpan = {
+            fileName: documentSpan.fileName,
+            textSpan: { start: 0, length: 0 },
+        };
     }
     if (!textSpan) {
         return;
@@ -174,4 +172,12 @@ function toGeneratedOffset(sourceScript, map, position, filter) {
     }
 }
 exports.toGeneratedOffset = toGeneratedOffset;
+function* forEachGeneratedOffset(sourceScript, map, position, filter) {
+    for (const [generateOffset, mapping] of map.getGeneratedOffsets(position)) {
+        if (filter(mapping.data)) {
+            yield generateOffset + sourceScript.snapshot.getLength();
+        }
+    }
+}
+exports.forEachGeneratedOffset = forEachGeneratedOffset;
 //# sourceMappingURL=transform.js.map

package/lib/protocol/createProject.js

@@ -5,10 +5,14 @@ const language_core_1 = require("@volar/language-core");
 const language_core_2 = require("@volar/language-core");
 const path = require("path-browserify");
 const resolveModuleName_1 = require("../resolveModuleName");
+const common_1 = require("../common");
 const scriptVersions = new Map();
 const fsFileSnapshots = new Map();
 function createTypeScriptLanguage(ts, languagePlugins, projectHost) {
-    const language = (0, language_core_1.createLanguage)(languagePlugins, projectHost.useCaseSensitiveFileNames, scriptId => {
+    const language = (0, language_core_1.createLanguage)([
+        ...languagePlugins,
+        common_1.fileLanguageIdProviderPlugin,
+    ], projectHost.useCaseSensitiveFileNames, scriptId => {
         const fileName = projectHost.scriptIdToFileName(scriptId);
         // opened files
         let snapshot = projectHost.getScriptSnapshot(fileName);
@@ -29,7 +33,7 @@ function createTypeScriptLanguage(ts, languagePlugins, projectHost) {
             snapshot = fsFileSnapshots.get(fileName)?.[1];
         }
         if (snapshot) {
-            language.scripts.set(scriptId, projectHost.getLanguageId(scriptId), snapshot);
+            language.scripts.set(scriptId, snapshot);
         }
         else {
             language.scripts.delete(scriptId);

package/lib/quickstart/createAsyncLanguageServicePlugin.d.ts

@@ -1,3 +1,3 @@
 import type * as ts from 'typescript';
 import { LanguagePlugin } from '@volar/language-core';
-export declare function createAsyncLanguageServicePlugin(extensions: string[], scriptKind: ts.ScriptKind, loadLanguagePlugins: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => Promise<LanguagePlugin[]>, getLanguageId: (fileName: string) => string): ts.server.PluginModuleFactory;
+export declare function createAsyncLanguageServicePlugin(extensions: string[], scriptKind: ts.ScriptKind, loadLanguagePlugins: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => Promise<LanguagePlugin[]>): ts.server.PluginModuleFactory;

package/lib/quickstart/createAsyncLanguageServicePlugin.js

@@ -5,10 +5,11 @@ const decorateLanguageService_1 = require("../node/decorateLanguageService");
 const decorateLanguageServiceHost_1 = require("../node/decorateLanguageServiceHost");
 const language_core_1 = require("@volar/language-core");
 const createLanguageServicePlugin_1 = require("./createLanguageServicePlugin");
+const common_1 = require("../common");
 const externalFiles = new WeakMap();
 const decoratedLanguageServices = new WeakSet();
 const decoratedLanguageServiceHosts = new WeakSet();
-function createAsyncLanguageServicePlugin(extensions, scriptKind, loadLanguagePlugins, getLanguageId) {
+function createAsyncLanguageServicePlugin(extensions, scriptKind, loadLanguagePlugins) {
     return modules => {
         const { typescript: ts } = modules;
         const pluginModule = {
@@ -52,10 +53,19 @@ function createAsyncLanguageServicePlugin(extensions, scriptKind, loadLanguagePl
                         };
                     }
                     loadLanguagePlugins(ts, info).then(languagePlugins => {
-                        const language = (0, language_core_1.createLanguage)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
+                        const syncedScriptVersions = new language_core_1.FileMap(ts.sys.useCaseSensitiveFileNames);
+                        const language = (0, language_core_1.createLanguage)([
+                            ...languagePlugins,
+                            common_1.fileLanguageIdProviderPlugin,
+                        ], ts.sys.useCaseSensitiveFileNames, fileName => {
+                            const version = getScriptVersion(fileName);
+                            if (syncedScriptVersions.get(fileName) === version) {
+                                return;
+                            }
+                            syncedScriptVersions.set(fileName, version);
                             const snapshot = getScriptSnapshot(fileName);
                             if (snapshot) {
-                                language.scripts.set(fileName, getLanguageId(fileName), snapshot);
+                                language.scripts.set(fileName, snapshot);
                             }
                             else {
                                 language.scripts.delete(fileName);

package/lib/quickstart/createLanguageServicePlugin.d.ts

@@ -1,4 +1,4 @@
 import type * as ts from 'typescript';
 import { LanguagePlugin } from '@volar/language-core';
-export declare function createLanguageServicePlugin(loadLanguagePlugins: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => LanguagePlugin[], getLanguageId: (fileName: string) => string): ts.server.PluginModuleFactory;
+export declare function createLanguageServicePlugin(loadLanguagePlugins: (ts: typeof import('typescript'), info: ts.server.PluginCreateInfo) => LanguagePlugin[]): ts.server.PluginModuleFactory;
 export declare function arrayItemsEqual(a: string[], b: string[]): boolean;

package/lib/quickstart/createLanguageServicePlugin.js

@@ -4,11 +4,12 @@ exports.arrayItemsEqual = exports.createLanguageServicePlugin = void 0;
 const decorateLanguageService_1 = require("../node/decorateLanguageService");
 const decorateLanguageServiceHost_1 = require("../node/decorateLanguageServiceHost");
 const language_core_1 = require("@volar/language-core");
+const common_1 = require("../common");
 const externalFiles = new WeakMap();
 const projectExternalFileExtensions = new WeakMap();
 const decoratedLanguageServices = new WeakSet();
 const decoratedLanguageServiceHosts = new WeakSet();
-function createLanguageServicePlugin(loadLanguagePlugins, getLanguageId) {
+function createLanguageServicePlugin(loadLanguagePlugins) {
     return modules => {
         const { typescript: ts } = modules;
         const pluginModule = {
@@ -23,10 +24,20 @@ function createLanguageServicePlugin(loadLanguagePlugins, getLanguageId) {
                         .flat();
                     projectExternalFileExtensions.set(info.project, extensions);
                     const getScriptSnapshot = info.languageServiceHost.getScriptSnapshot.bind(info.languageServiceHost);
-                    const language = (0, language_core_1.createLanguage)(languagePlugins, ts.sys.useCaseSensitiveFileNames, fileName => {
+                    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,
+                        common_1.fileLanguageIdProviderPlugin,
+                    ], ts.sys.useCaseSensitiveFileNames, fileName => {
+                        const version = getScriptVersion(fileName);
+                        if (syncedScriptVersions.get(fileName) === version) {
+                            return;
+                        }
+                        syncedScriptVersions.set(fileName, version);
                         const snapshot = getScriptSnapshot(fileName);
                         if (snapshot) {
-                            language.scripts.set(fileName, getLanguageId(fileName), snapshot);
+                            language.scripts.set(fileName, snapshot);
                         }
                         else {
                             language.scripts.delete(fileName);

package/lib/quickstart/runTsc.d.ts

@@ -1,5 +1,4 @@
 import type * as ts from 'typescript';
 import type { LanguagePlugin } from '@volar/language-core';
 export declare let getLanguagePlugins: (ts: typeof import('typescript'), options: ts.CreateProgramOptions) => LanguagePlugin[];
-export declare let getLanguageId: (fileName: string) => string;
-export declare function runTsc(tscPath: string, extensions: string[], _getLanguagePlugins: typeof getLanguagePlugins, _getLanguageId: typeof getLanguageId): void;
+export declare function runTsc(tscPath: string, extensions: string[], _getLanguagePlugins: typeof getLanguagePlugins): void;

package/lib/quickstart/runTsc.js

@@ -1,14 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runTsc = exports.getLanguageId = exports.getLanguagePlugins = void 0;
+exports.runTsc = exports.getLanguagePlugins = void 0;
 const fs = require("fs");
 let getLanguagePlugins = () => [];
 exports.getLanguagePlugins = getLanguagePlugins;
-let getLanguageId = () => 'ts';
-exports.getLanguageId = getLanguageId;
-function runTsc(tscPath, extensions, _getLanguagePlugins, _getLanguageId) {
+function runTsc(tscPath, extensions, _getLanguagePlugins) {
     exports.getLanguagePlugins = _getLanguagePlugins;
-    exports.getLanguageId = _getLanguageId;
     const proxyApiPath = require.resolve('../node/proxyCreateProgram');
     const readFileSync = fs.readFileSync;
     fs.readFileSync = (...args) => {
@@ -25,7 +22,6 @@ function runTsc(tscPath, extensions, _getLanguagePlugins, _getLanguageId) {
                     `new Proxy({}, { get(_target, p, _receiver) { return eval(p); } } )`,
                     `_createProgram`,
                     `require(${JSON.stringify(__filename)}).getLanguagePlugins`,
-                    `require(${JSON.stringify(__filename)}).getLanguageId`,
                 ].join(', ')
                 + `);\n`
                 + s.replace('createProgram', '_createProgram'));

package/lib/resolveModuleName.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createResolveModuleName = void 0;
 function createResolveModuleName(ts, host, languagePlugins, getSourceScript) {
-    const toPatchResults = new Map();
+    const toSourceFileInfo = new Map();
     const moduleResolutionHost = {
         readFile: host.readFile.bind(host),
         directoryExists: host.directoryExists?.bind(host),
@@ -19,10 +19,28 @@ function createResolveModuleName(ts, host, languagePlugins, getSourceScript) {
                 }
                 for (const { extension } of typescript.extraFileExtensions) {
                     if (fileName.endsWith(`.d.${extension}.ts`)) {
-                        const patchFileName = fileName.slice(0, -`.d.${extension}.ts`.length) + `.${extension}`;
-                        if (fileExists(patchFileName)) {
-                            toPatchResults.set(fileName, patchFileName);
-                            return true;
+                        const sourceFileName = fileName.slice(0, -`.d.${extension}.ts`.length) + `.${extension}`;
+                        if (fileExists(sourceFileName)) {
+                            const sourceScript = getSourceScript(sourceFileName);
+                            if (sourceScript?.generated) {
+                                const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+                                if (serviceScript) {
+                                    const dtsPath = sourceFileName + '.d.ts';
+                                    if ((serviceScript.extension === '.js' || serviceScript.extension === '.jsx') && fileExists(dtsPath)) {
+                                        toSourceFileInfo.set(fileName, {
+                                            sourceFileName: dtsPath,
+                                            extension: '.ts',
+                                        });
+                                    }
+                                    else {
+                                        toSourceFileInfo.set(fileName, {
+                                            sourceFileName,
+                                            extension: serviceScript.extension,
+                                        });
+                                    }
+                                    return true;
+                                }
+                            }
                         }
                     }
                 }
@@ -32,17 +50,14 @@ function createResolveModuleName(ts, host, languagePlugins, getSourceScript) {
     };
     return (moduleName, containingFile, compilerOptions, cache, redirectedReference, resolutionMode) => {
         const result = ts.resolveModuleName(moduleName, containingFile, compilerOptions, moduleResolutionHost, cache, redirectedReference, resolutionMode);
-        if (result.resolvedModule && toPatchResults.has(result.resolvedModule.resolvedFileName)) {
-            result.resolvedModule.resolvedFileName = toPatchResults.get(result.resolvedModule.resolvedFileName);
-            const sourceScript = getSourceScript(result.resolvedModule.resolvedFileName);
-            if (sourceScript?.generated) {
-                const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
-                if (serviceScript) {
-                    result.resolvedModule.extension = serviceScript.extension;
-                }
+        if (result.resolvedModule) {
+            const sourceFileInfo = toSourceFileInfo.get(result.resolvedModule.resolvedFileName);
+            if (sourceFileInfo) {
+                result.resolvedModule.resolvedFileName = sourceFileInfo.sourceFileName;
+                result.resolvedModule.extension = sourceFileInfo.extension;
             }
         }
-        toPatchResults.clear();
+        toSourceFileInfo.clear();
         return result;
     };
     // fix https://github.com/vuejs/language-tools/issues/3332

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/typescript",
-	"version": "2.2.0-alpha.8",
+	"version": "2.2.0",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,13 +12,13 @@
 		"directory": "packages/typescript"
 	},
 	"dependencies": {
-		"@volar/language-core": "2.2.0-alpha.8",
+		"@volar/language-core": "2.2.0",
 		"path-browserify": "^1.0.1"
 	},
 	"devDependencies": {
 		"@types/node": "latest",
 		"@types/path-browserify": "latest",
-		"@volar/language-service": "2.2.0-alpha.8"
+		"@volar/language-service": "2.2.0"
 	},
-	"gitHead": "a48e2549a5bf216ab655e4ef7e6d8c545d10d558"
+	"gitHead": "c6e8d2765bbd2ec4a37374fd3a3a31c02661e8b3"
 }

package/lib/documentRegistry.d.ts

@@ -1,2 +0,0 @@
-import type * as ts from 'typescript';
-export declare function getDocumentRegistry(ts: typeof import('typescript'), useCaseSensitiveFileNames: boolean, currentDirectory: string): ts.DocumentRegistry;

package/lib/documentRegistry.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDocumentRegistry = void 0;
-const documentRegistries = [];
-function getDocumentRegistry(ts, useCaseSensitiveFileNames, currentDirectory) {
-    let documentRegistry = documentRegistries.find(item => item[0] === useCaseSensitiveFileNames && item[1] === currentDirectory)?.[2];
-    if (!documentRegistry) {
-        documentRegistry = ts.createDocumentRegistry(useCaseSensitiveFileNames, currentDirectory);
-        documentRegistries.push([useCaseSensitiveFileNames, currentDirectory, documentRegistry]);
-    }
-    return documentRegistry;
-}
-exports.getDocumentRegistry = getDocumentRegistry;
-//# sourceMappingURL=documentRegistry.js.map