@volar/typescript 1.11.1 → 2.0.0-alpha.1

package/lib/{serverPlugin.js → node/decorateLanguageServiceHost.js}

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExternalFiles = exports.searchExternalFiles = exports.decorateLanguageServiceHost = void 0;
+exports.searchExternalFiles = exports.decorateLanguageServiceHost = void 0;
 const language_core_1 = require("@volar/language-core");
+const language_service_1 = require("@volar/language-service");
 function decorateLanguageServiceHost(virtualFiles, languageServiceHost, ts, exts) {
     let extraProjectVersion = 0;
     const scripts = new Map();
@@ -70,18 +71,7 @@ function decorateLanguageServiceHost(virtualFiles, languageServiceHost, ts, exts
                 updateScript(fileName);
                 const script = scripts.get(fileName);
                 if (script) {
-                    if (script.extension.endsWith('.js')) {
-                        return ts.ScriptKind.JS;
-                    }
-                    if (script.extension.endsWith('.jsx')) {
-                        return ts.ScriptKind.JSX;
-                    }
-                    if (script.extension.endsWith('.ts')) {
-                        return ts.ScriptKind.TS;
-                    }
-                    if (script.extension.endsWith('.tsx')) {
-                        return ts.ScriptKind.TSX;
-                    }
+                    return script.kind;
                 }
                 return ts.ScriptKind.Deferred;
             }
@@ -120,32 +110,36 @@ function decorateLanguageServiceHost(virtualFiles, languageServiceHost, ts, exts
     function updateScript(fileName) {
         const version = languageServiceHost.getScriptVersion(fileName);
         if (version !== scripts.get(fileName)?.version) {
-            const text = languageServiceHost.readFile(fileName);
-            let snapshot;
             let extension = '.ts';
-            if (text !== undefined) {
+            let snapshotSnapshot;
+            let scriptKind = ts.ScriptKind.TS;
+            const snapshot = getScriptSnapshot(fileName);
+            if (snapshot) {
                 extraProjectVersion++;
-                const virtualFile = virtualFiles.updateSource(fileName, ts.ScriptSnapshot.fromString(text), undefined);
-                if (virtualFile) {
+                const sourceFile = virtualFiles.updateSourceFile(fileName, (0, language_service_1.resolveCommonLanguageId)(fileName), snapshot);
+                if (sourceFile.virtualFile) {
+                    const text = snapshot.getText(0, snapshot.getLength());
                     let patchedText = text.split('\n').map(line => ' '.repeat(line.length)).join('\n');
-                    (0, language_core_1.forEachEmbeddedFile)(virtualFile, file => {
-                        const ext = file.fileName.substring(fileName.length);
-                        if (file.kind === language_core_1.FileKind.TypeScriptHostFile && (ext === '.d.ts' || ext.match(/^\.(js|ts)x?$/))) {
+                    for (const file of (0, language_core_1.forEachEmbeddedFile)(sourceFile.virtualFile[0])) {
+                        const ext = file.id.substring(fileName.length);
+                        if (file.typescript && (ext === '.d.ts' || ext.match(/^\.(js|ts)x?$/))) {
                             extension = ext;
+                            scriptKind = file.typescript.scriptKind;
                             patchedText += file.snapshot.getText(0, file.snapshot.getLength());
                         }
-                    });
-                    snapshot = ts.ScriptSnapshot.fromString(patchedText);
+                    }
+                    snapshotSnapshot = ts.ScriptSnapshot.fromString(patchedText);
                 }
             }
-            else if (virtualFiles.hasSource(fileName)) {
+            else if (virtualFiles.getSourceFile(fileName)) {
                 extraProjectVersion++;
-                virtualFiles.deleteSource(fileName);
+                virtualFiles.deleteSourceFile(fileName);
             }
             scripts.set(fileName, {
                 version,
-                snapshot,
                 extension,
+                snapshot: snapshotSnapshot,
+                kind: scriptKind,
             });
         }
         return scripts.get(fileName);
@@ -171,8 +165,4 @@ function searchExternalFiles(ts, project, exts) {
     return parsed.fileNames;
 }
 exports.searchExternalFiles = searchExternalFiles;
-/**
- * @deprecated use `searchExternalFiles` instead
- */
-exports.getExternalFiles = searchExternalFiles;
-//# sourceMappingURL=serverPlugin.js.map
+//# sourceMappingURL=decorateLanguageServiceHost.js.map

package/lib/node/dedupe.d.ts

@@ -0,0 +1,3 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+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

@@ -0,0 +1,27 @@
+"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;
+function dedupeDocumentSpans(items) {
+    return dedupe(items, item => [
+        item.fileName,
+        item.textSpan.start,
+        item.textSpan.length,
+    ].join(':'));
+}
+exports.dedupeDocumentSpans = dedupeDocumentSpans;
+function dedupe(items, getKey) {
+    const map = new Map();
+    for (const item of items.reverse()) {
+        map.set(getKey(item), item);
+    }
+    return [...map.values()];
+}
+//# sourceMappingURL=dedupe.js.map

package/lib/protocol/createProject.d.ts

@@ -0,0 +1,4 @@
+import { LanguagePlugin, Language, TypeScriptProjectHost } from '@volar/language-core';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type { createSys } from './createSys';
+export declare function createLanguage(ts: typeof import('typescript/lib/tsserverlibrary'), sys: ReturnType<typeof createSys> | ts.System, languages: LanguagePlugin<any>[], configFileName: string | undefined, projectHost: TypeScriptProjectHost): Language;

package/lib/protocol/createProject.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguage = void 0;
+const language_core_1 = require("@volar/language-core");
+const language_core_2 = require("@volar/language-core");
+const path = require("path-browserify");
+const utilities_1 = require("../typescript/utilities");
+const scriptVersions = new Map();
+const fsFileSnapshots = new Map();
+function createLanguage(ts, sys, languages, configFileName, projectHost) {
+    const files = (0, language_core_1.createFileProvider)(languages, sys.useCaseSensitiveFileNames, (id) => {
+        const fileName = projectHost.getFileName(id);
+        // opened files
+        let snapshot = projectHost.getScriptSnapshot(fileName);
+        if (!snapshot) {
+            // fs files
+            const cache = fsFileSnapshots.get(fileName);
+            const modifiedTime = sys.getModifiedTime?.(fileName)?.valueOf();
+            if (!cache || cache[0] !== modifiedTime) {
+                if (sys.fileExists(fileName)) {
+                    const text = sys.readFile(fileName);
+                    const snapshot = text !== undefined ? ts.ScriptSnapshot.fromString(text) : undefined;
+                    fsFileSnapshots.set(fileName, [modifiedTime, snapshot]);
+                }
+                else {
+                    fsFileSnapshots.set(fileName, [modifiedTime, undefined]);
+                }
+            }
+            snapshot = fsFileSnapshots.get(fileName)?.[1];
+        }
+        if (snapshot) {
+            files.updateSourceFile(id, projectHost.getLanguageId(id), snapshot);
+        }
+        else {
+            files.deleteSourceFile(id);
+        }
+    });
+    let languageServiceHost = createLanguageServiceHost();
+    for (const language of languages) {
+        if (language.typescript?.resolveLanguageServiceHost) {
+            languageServiceHost = language.typescript.resolveLanguageServiceHost(languageServiceHost);
+        }
+    }
+    if (languages.some(language => language.typescript?.resolveModuleName)) {
+        // TODO: can this share between monorepo packages?
+        const moduleCache = ts.createModuleResolutionCache(languageServiceHost.getCurrentDirectory(), languageServiceHost.useCaseSensitiveFileNames ? s => s : s => s.toLowerCase(), languageServiceHost.getCompilationSettings());
+        let lastSysVersion = 'version' in sys ? sys.version : undefined;
+        languageServiceHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, sourceFile) => {
+            if ('version' in sys && lastSysVersion !== sys.version) {
+                lastSysVersion = sys.version;
+                moduleCache.clear();
+            }
+            return moduleLiterals.map((moduleLiteral) => {
+                let moduleName = moduleLiteral.text;
+                for (const language of languages) {
+                    if (language.typescript?.resolveModuleName) {
+                        moduleName = language.typescript.resolveModuleName(moduleName, sourceFile.impliedNodeFormat) ?? moduleName;
+                    }
+                }
+                return ts.resolveModuleName(moduleName, containingFile, options, languageServiceHost, moduleCache, redirectedReference, sourceFile.impliedNodeFormat);
+            });
+        };
+        languageServiceHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options, sourceFile) => {
+            if ('version' in sys && lastSysVersion !== sys.version) {
+                lastSysVersion = sys.version;
+                moduleCache.clear();
+            }
+            return moduleNames.map((moduleName) => {
+                for (const language of languages) {
+                    if (language.typescript?.resolveModuleName) {
+                        moduleName = language.typescript.resolveModuleName(moduleName, sourceFile?.impliedNodeFormat) ?? moduleName;
+                    }
+                }
+                return ts.resolveModuleName(moduleName, containingFile, options, languageServiceHost, moduleCache, redirectedReference, sourceFile?.impliedNodeFormat).resolvedModule;
+            });
+        };
+    }
+    return {
+        files,
+        typescript: {
+            configFileName,
+            sys,
+            projectHost,
+            languageServiceHost,
+            synchronizeFileSystem: 'sync' in sys ? () => sys.sync() : undefined,
+        },
+    };
+    function createLanguageServiceHost() {
+        let lastProjectVersion;
+        let tsProjectVersion = 0;
+        let tsFileRegistry = new language_core_1.FileMap(sys.useCaseSensitiveFileNames);
+        let lastTsVirtualFileSnapshots = new Set();
+        let lastOtherVirtualFileSnapshots = new Set();
+        const languageServiceHost = {
+            ...sys,
+            getCurrentDirectory: projectHost.getCurrentDirectory,
+            getCompilationSettings: projectHost.getCompilationSettings,
+            getCancellationToken: projectHost.getCancellationToken,
+            getLocalizedDiagnosticMessages: projectHost.getLocalizedDiagnosticMessages,
+            getProjectReferences: projectHost.getProjectReferences,
+            getDefaultLibFileName: (options) => {
+                try {
+                    return ts.getDefaultLibFilePath(options);
+                }
+                catch {
+                    // web
+                    return `/node_modules/typescript/lib/${ts.getDefaultLibFileName(options)}`;
+                }
+            },
+            useCaseSensitiveFileNames() {
+                return sys.useCaseSensitiveFileNames;
+            },
+            getNewLine() {
+                return sys.newLine;
+            },
+            getTypeRootsVersion: () => {
+                return 'version' in sys ? sys.version : -1; // TODO: only update for /node_modules changes?
+            },
+            // need sync
+            getDirectories(dirName) {
+                syncProject();
+                return [...new Set([
+                        ...getVirtualFileDirectories(dirName),
+                        ...sys.getDirectories(dirName),
+                    ])];
+            },
+            readFile(fileName) {
+                syncSourceFile(fileName);
+                const snapshot = getScriptSnapshot(fileName);
+                if (snapshot) {
+                    return snapshot.getText(0, snapshot.getLength());
+                }
+            },
+            fileExists(fileName) {
+                syncSourceFile(fileName);
+                return getScriptVersion(fileName) !== '';
+            },
+            readDirectory(dirName, extensions, excludes, includes, depth) {
+                syncProject();
+                let matches = (0, utilities_1.matchFiles)(dirName, extensions, excludes, includes, sys?.useCaseSensitiveFileNames ?? false, projectHost.getCurrentDirectory(), depth, (dirPath) => {
+                    const files = [];
+                    for (const fileName of tsFileRegistry.keys()) {
+                        if (fileName.toLowerCase().startsWith(dirPath.toLowerCase())) {
+                            const baseName = fileName.substring(dirPath.length);
+                            if (baseName.indexOf('/') === -1) {
+                                files.push(baseName);
+                            }
+                        }
+                    }
+                    return {
+                        files,
+                        directories: getVirtualFileDirectories(dirPath),
+                    };
+                }, sys?.realpath ? (path => sys.realpath(path)) : (path => path));
+                matches = matches.map(match => {
+                    const [_, source] = files.getVirtualFile(projectHost.getFileId(match));
+                    if (source) {
+                        return projectHost.getFileName(source.id);
+                    }
+                    return match;
+                });
+                return [...new Set([
+                        ...matches,
+                        ...sys.readDirectory(dirName, extensions, excludes, includes, depth),
+                    ])];
+            },
+            getProjectVersion() {
+                syncProject();
+                return tsProjectVersion + ('version' in sys ? `:${sys.version}` : '');
+            },
+            getScriptFileNames() {
+                syncProject();
+                return [...tsFileRegistry.keys()];
+            },
+            getScriptKind(fileName) {
+                syncSourceFile(fileName);
+                const virtualFile = files.getVirtualFile(projectHost.getFileId(fileName))[0];
+                if (virtualFile?.typescript) {
+                    return virtualFile.typescript.scriptKind;
+                }
+                const sourceFile = files.getSourceFile(projectHost.getFileId(fileName));
+                if (sourceFile?.virtualFile) {
+                    return ts.ScriptKind.Deferred;
+                }
+                switch (path.extname(fileName)) {
+                    case '.js':
+                    case '.cjs':
+                    case '.mjs':
+                        return ts.ScriptKind.JS;
+                    case '.jsx':
+                        return ts.ScriptKind.JSX;
+                    case '.ts':
+                    case '.cts':
+                    case '.mts':
+                        return ts.ScriptKind.TS;
+                    case '.tsx':
+                        return ts.ScriptKind.TSX;
+                    case '.json':
+                        return ts.ScriptKind.JSON;
+                    default:
+                        return ts.ScriptKind.Unknown;
+                }
+            },
+            getScriptVersion,
+            getScriptSnapshot,
+        };
+        return languageServiceHost;
+        function syncSourceFile(tsFileName) {
+            for (const language of languages) {
+                const sourceFileName = language.typescript?.resolveSourceFileName(tsFileName);
+                if (sourceFileName) {
+                    files.getSourceFile(projectHost.getFileId(sourceFileName)); // trigger sync
+                }
+            }
+        }
+        function syncProject() {
+            const newProjectVersion = projectHost.getProjectVersion?.();
+            const shouldUpdate = newProjectVersion === undefined || newProjectVersion !== lastProjectVersion;
+            if (!shouldUpdate)
+                return;
+            lastProjectVersion = newProjectVersion;
+            const newTsVirtualFileSnapshots = new Set();
+            const newOtherVirtualFileSnapshots = new Set();
+            const tsFileNamesSet = new Set();
+            for (const fileName of projectHost.getScriptFileNames()) {
+                const uri = projectHost.getFileId(fileName);
+                const sourceFile = files.getSourceFile(uri);
+                if (sourceFile?.virtualFile) {
+                    for (const file of (0, language_core_2.forEachEmbeddedFile)(sourceFile.virtualFile[0])) {
+                        if (file.typescript) {
+                            newTsVirtualFileSnapshots.add(file.snapshot);
+                            tsFileNamesSet.add(projectHost.getFileName(file.id)); // virtual .ts
+                        }
+                        else {
+                            newOtherVirtualFileSnapshots.add(file.snapshot);
+                        }
+                    }
+                }
+                else {
+                    tsFileNamesSet.add(fileName);
+                }
+            }
+            if (!setEquals(lastTsVirtualFileSnapshots, newTsVirtualFileSnapshots)) {
+                tsProjectVersion++;
+            }
+            else if (setEquals(lastOtherVirtualFileSnapshots, newOtherVirtualFileSnapshots)) {
+                // no any meta language files update, it mean project version was update by source files this time
+                tsProjectVersion++;
+            }
+            lastTsVirtualFileSnapshots = newTsVirtualFileSnapshots;
+            lastOtherVirtualFileSnapshots = newOtherVirtualFileSnapshots;
+            tsFileRegistry.clear();
+            for (const fileName of tsFileNamesSet) {
+                tsFileRegistry.set(fileName, true);
+            }
+        }
+        function getScriptSnapshot(fileName) {
+            syncSourceFile(fileName);
+            const uri = projectHost.getFileId(fileName);
+            const virtualFile = files.getVirtualFile(uri)[0];
+            if (virtualFile) {
+                return virtualFile.snapshot;
+            }
+            const sourceFile = files.getSourceFile(uri);
+            if (sourceFile && !sourceFile.virtualFile) {
+                return sourceFile.snapshot;
+            }
+        }
+        function getScriptVersion(fileName) {
+            syncSourceFile(fileName);
+            if (!scriptVersions.has(fileName)) {
+                scriptVersions.set(fileName, { lastVersion: 0, map: new WeakMap() });
+            }
+            const version = scriptVersions.get(fileName);
+            const virtualFile = files.getVirtualFile(projectHost.getFileId(fileName))[0];
+            if (virtualFile) {
+                if (!version.map.has(virtualFile.snapshot)) {
+                    version.map.set(virtualFile.snapshot, version.lastVersion++);
+                }
+                return version.map.get(virtualFile.snapshot).toString();
+            }
+            const isOpenedFile = !!projectHost.getScriptSnapshot(fileName);
+            if (isOpenedFile) {
+                const sourceFile = files.getSourceFile(projectHost.getFileId(fileName));
+                if (sourceFile && !sourceFile.virtualFile) {
+                    if (!version.map.has(sourceFile.snapshot)) {
+                        version.map.set(sourceFile.snapshot, version.lastVersion++);
+                    }
+                    return version.map.get(sourceFile.snapshot).toString();
+                }
+            }
+            if (sys.fileExists(fileName)) {
+                return sys.getModifiedTime?.(fileName)?.valueOf().toString() ?? '0';
+            }
+            return '';
+        }
+        function getVirtualFileDirectories(dirName) {
+            const names = new Set();
+            for (const fileName of tsFileRegistry.keys()) {
+                if (fileName.toLowerCase().startsWith(dirName.toLowerCase())) {
+                    const path = fileName.substring(dirName.length);
+                    if (path.indexOf('/') >= 0) {
+                        names.add(path.split('/')[0]);
+                    }
+                }
+            }
+            return [...names];
+        }
+    }
+}
+exports.createLanguage = createLanguage;
+function setEquals(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const item of a) {
+        if (!b.has(item))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=createProject.js.map

package/lib/{sys.d.ts → protocol/createSys.d.ts}

@@ -1,7 +1,6 @@
 import type { ServiceEnvironment, Disposable } from '@volar/language-service';
 import type * as ts from 'typescript/lib/tsserverlibrary';
-export declare function createSys(ts: typeof import('typescript/lib/tsserverlibrary'), env: ServiceEnvironment): ts.System & {
+export declare function createSys(ts: typeof import('typescript/lib/tsserverlibrary'), env: ServiceEnvironment, currentDirectory: string): ts.System & {
     version: number;
     sync(): Promise<number>;
 } & Disposable;
-//# sourceMappingURL=sys.d.ts.map

package/lib/{sys.js → protocol/createSys.js}

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSys = void 0;
 const path = require("path-browserify");
-const utilities_1 = require("./typescript/utilities");
+const utilities_1 = require("../typescript/utilities");
 let currentCwd = '';
-function createSys(ts, env) {
+function createSys(ts, env, currentDirectory) {
     let version = 0;
-    const rootPath = env.uriToFileName(env.workspaceUri.toString());
+    const rootPath = currentDirectory;
     const sys = ts.sys;
     const root = {
         dirs: new Map(),
@@ -45,9 +45,6 @@ function createSys(ts, env) {
         }
     });
     return {
-        get version() {
-            return version;
-        },
         dispose() {
             fileWatcher?.dispose();
         },
@@ -68,6 +65,9 @@ function createSys(ts, env) {
         resolvePath,
         fileExists,
         directoryExists,
+        get version() {
+            return version;
+        },
         async sync() {
             while (promises.size) {
                 await Promise.all(promises);
@@ -84,7 +84,7 @@ function createSys(ts, env) {
                 if (sys.directoryExists(rootPath)) {
                     // https://github.com/vuejs/language-tools/issues/2480
                     try {
-                        // @ts-expect-error
+                        // @ts-ignore
                         process.chdir(rootPath);
                     }
                     catch { }
@@ -338,4 +338,4 @@ function createSys(ts, env) {
     }
 }
 exports.createSys = createSys;
-//# sourceMappingURL=sys.js.map
+//# sourceMappingURL=createSys.js.map

package/lib/protocol/getProgram.d.ts

@@ -0,0 +1,6 @@
+import { type FileProvider } from '@volar/language-core';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function getProgram(ts: typeof import('typescript/lib/tsserverlibrary'), files: FileProvider, { getFileId, getFileName }: {
+    getFileId(fileName: string): string;
+    getFileName(id: string): string;
+}, ls: ts.LanguageService, sys: ts.System): ts.Program;

package/lib/{getProgram.js → protocol/getProgram.js}

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProgram = void 0;
-function getProgram(ts, core, ls, sys) {
+const language_core_1 = require("@volar/language-core");
+function getProgram(ts, files, { getFileId, getFileName }, ls, sys) {
     const proxy = {
         getRootFileNames,
         emit,
@@ -49,9 +50,10 @@ function getProgram(ts, core, ls, sys) {
     }
     function getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, api) {
         if (sourceFile) {
-            const [virtualFile, source] = core.virtualFiles.getVirtualFile(sourceFile.fileName);
+            const uri = getFileId(sourceFile.fileName);
+            const [virtualFile, source] = files.getVirtualFile(uri);
             if (virtualFile && source) {
-                if (!virtualFile.capabilities.diagnostic)
+                if (!virtualFile.mappings.some(mapping => (0, language_core_1.isDiagnosticsEnabled)(mapping.data)))
                     return [];
                 const errors = transformDiagnostics(ls.getProgram()?.[api](sourceFile, cancellationToken) ?? []);
                 return errors;
@@ -77,22 +79,22 @@ function getProgram(ts, core, ls, sys) {
             if (diagnostic.file !== undefined
                 && diagnostic.start !== undefined
                 && diagnostic.length !== undefined) {
-                const [virtualFile, source] = core.virtualFiles.getVirtualFile(diagnostic.file.fileName);
+                const uri = getFileId(diagnostic.file.fileName);
+                const [virtualFile, source] = files.getVirtualFile(uri);
                 if (virtualFile && source) {
-                    if (sys.fileExists?.(source.fileName) === false)
+                    const sourceFileName = getFileName(source.id);
+                    if (sys.fileExists?.(sourceFileName) === false)
                         continue;
-                    for (const [_, [sourceSnapshot, map]] of core.virtualFiles.getMaps(virtualFile)) {
+                    for (const [_, [sourceSnapshot, map]] of files.getMaps(virtualFile)) {
                         if (sourceSnapshot !== source.snapshot)
                             continue;
-                        for (const start of map.toSourceOffsets(diagnostic.start)) {
-                            const reportStart = typeof start[1].data.diagnostic === 'object' ? start[1].data.diagnostic.shouldReport() : !!start[1].data.diagnostic;
-                            if (!reportStart)
+                        for (const start of map.getSourceOffsets(diagnostic.start)) {
+                            if (!(0, language_core_1.shouldReportDiagnostics)(start[1].data))
                                 continue;
-                            for (const end of map.toSourceOffsets(diagnostic.start + diagnostic.length, true)) {
-                                const reportEnd = typeof end[1].data.diagnostic === 'object' ? end[1].data.diagnostic.shouldReport() : !!end[1].data.diagnostic;
-                                if (!reportEnd)
+                            for (const end of map.getSourceOffsets(diagnostic.start + diagnostic.length)) {
+                                if (!(0, language_core_1.shouldReportDiagnostics)(end[1].data))
                                     continue;
-                                onMapping(diagnostic, source.fileName, start[0], end[0], source.snapshot.getText(0, source.snapshot.getLength()));
+                                onMapping(diagnostic, sourceFileName, start[0], end[0], source.snapshot.getText(0, source.snapshot.getLength()));
                                 break;
                             }
                             break;
@@ -116,7 +118,8 @@ function getProgram(ts, core, ls, sys) {
                 : undefined;
             if (!file) {
                 if (docText === undefined) {
-                    const snapshot = core.host.getScriptSnapshot(fileName);
+                    const uri = getFileId(fileName);
+                    const snapshot = files.getSourceFile(uri)?.snapshot;
                     if (snapshot) {
                         docText = snapshot.getText(0, snapshot.getLength());
                     }

package/lib/typescript/core.d.ts

@@ -81,4 +81,3 @@ type GetCanonicalFileName = (fileName: string) => string;
 export declare function createGetCanonicalFileName(useCaseSensitiveFileNames: boolean): GetCanonicalFileName;
 export declare function startsWith(str: string, prefix: string): boolean;
 export {};
-//# sourceMappingURL=core.d.ts.map

package/lib/typescript/core.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startsWith = exports.createGetCanonicalFileName = exports.stringContains = exports.endsWith = exports.getStringComparer = exports.compareStringsCaseSensitive = exports.equateStringsCaseSensitive = exports.equateStringsCaseInsensitive = exports.last = exports.lastOrUndefined = exports.sort = exports.some = exports.flatMap = exports.flatten = exports.map = exports.indexOfAnyCharCode = exports.findIndex = exports.every = void 0;
+require("./corePublic");
 const emptyArray = [];
 /**
  * Iterates through `array` by index and performs the callback on each element of array until the callback

package/lib/typescript/corePublic.d.ts

@@ -89,4 +89,3 @@ export declare const enum Comparison {
 }
 export declare const Map: MapConstructor;
 export declare const Set: SetConstructor;
-//# sourceMappingURL=corePublic.d.ts.map

package/lib/typescript/corePublic.js

@@ -12,7 +12,7 @@ exports.version = `${exports.versionMajorMinor}.0-dev`;
 var NativeCollections;
 (function (NativeCollections) {
     const globals = typeof globalThis !== "undefined" ? globalThis :
-        // @ts-expect-error node global
+        // @ts-ignore node global
         typeof global !== "undefined" ? global :
             typeof self !== "undefined" ? self :
                 undefined;

package/lib/typescript/path.d.ts

@@ -110,4 +110,3 @@ export declare function removeTrailingDirectorySeparator(path: string): string;
  */
 export declare function containsPath(parent: string, child: string, ignoreCase?: boolean): boolean;
 export declare function containsPath(parent: string, child: string, currentDirectory: string, ignoreCase?: boolean): boolean;
-//# sourceMappingURL=path.d.ts.map

package/lib/typescript/path.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.containsPath = exports.removeTrailingDirectorySeparator = exports.normalizePath = exports.getNormalizedPathComponents = exports.combinePaths = exports.getDirectoryPath = exports.fileExtensionIsOneOf = exports.hasExtension = exports.isRootedDiskPath = exports.directorySeparator = void 0;
 const core_1 = require("./core");
+require("./types");
 /**
  * Internally, we represent paths as strings with '/' as the directory separator.
  * When we make system calls (eg: LanguageServiceHost.getDirectory()),