@volar/typescript 1.6.9 → 1.7.1-patch.1

package/out/documentRegistry.d.ts

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

package/out/documentRegistry.js

@@ -0,0 +1,14 @@
+"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

package/out/dtsHost.d.ts

@@ -0,0 +1,26 @@
+import type { FileStat, FileType } from '@volar/language-service';
+export interface IDtsHost {
+    stat(uri: string): Promise<FileStat | undefined>;
+    readFile(fileName: string): Promise<string | undefined>;
+    readDirectory(dirName: string): Promise<[string, FileType][]>;
+}
+export declare function createJsDelivrDtsHost(versions?: Record<string, string>, onFetch?: (fileName: string, text: string) => void): DtsHost;
+declare class DtsHost implements IDtsHost {
+    private fetchText;
+    private flat;
+    fetchResults: Map<string, Promise<string | undefined>>;
+    flatResults: Map<string, Promise<string[]>>;
+    constructor(fetchText: (path: string) => Promise<string | undefined>, flat: (pkg: string) => Promise<string[]>);
+    stat(fileName: string): Promise<{
+        type: number;
+        ctime: number;
+        mtime: number;
+        size: number;
+    } | undefined>;
+    readDirectory(dirName: string): Promise<[string, FileType][]>;
+    readFile(fileName: string): Promise<string | undefined>;
+    fetchFile(fileName: string): Promise<string | undefined>;
+    valid(fileName: string): Promise<boolean>;
+}
+export declare function getPackageNameOfDtsPath(path: string): string | undefined;
+export {};

package/out/dtsHost.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageNameOfDtsPath = exports.createJsDelivrDtsHost = void 0;
+function createJsDelivrDtsHost(versions = {}, onFetch) {
+    return new DtsHost(async (fileName) => {
+        const requestFileName = resolveRequestFileName(fileName);
+        const url = 'https://cdn.jsdelivr.net/npm/' + requestFileName.slice('/node_modules/'.length);
+        const text = await fetchText(url);
+        if (text !== undefined) {
+            onFetch?.(fileName, text);
+        }
+        return text;
+    }, async (pkg) => {
+        let version = versions[pkg];
+        if (!version) {
+            const data = await fetchJson(`https://data.jsdelivr.com/v1/package/resolve/npm/${pkg}@latest`);
+            if (data?.version) {
+                version = data.version;
+            }
+        }
+        if (!version) {
+            return [];
+        }
+        const flat = await fetchJson(`https://data.jsdelivr.com/v1/package/npm/${pkg}@${version}/flat`);
+        if (!flat) {
+            return [];
+        }
+        return flat.files.map(file => file.name);
+    });
+    function resolveRequestFileName(fileName) {
+        for (const [key, version] of Object.entries(versions)) {
+            if (fileName.startsWith(`/node_modules/${key}/`)) {
+                fileName = fileName.replace(`/node_modules/${key}/`, `/node_modules/${key}@${version}/`);
+                return fileName;
+            }
+        }
+        return fileName;
+    }
+}
+exports.createJsDelivrDtsHost = createJsDelivrDtsHost;
+class DtsHost {
+    constructor(fetchText, flat) {
+        this.fetchText = fetchText;
+        this.flat = flat;
+        this.fetchResults = new Map();
+        this.flatResults = new Map();
+    }
+    async stat(fileName) {
+        if (!await this.valid(fileName)) {
+            return;
+        }
+        const pkgName = getPackageNameOfDtsPath(fileName);
+        if (!pkgName) {
+            return;
+        }
+        if (!this.flatResults.has(pkgName)) {
+            this.flatResults.set(pkgName, this.flat(pkgName));
+        }
+        const flat = await this.flatResults.get(pkgName);
+        const filePath = fileName.slice(`/node_modules/${pkgName}`.length);
+        if (flat.includes(filePath)) {
+            return {
+                type: 1,
+                ctime: -1,
+                mtime: -1,
+                size: -1,
+            };
+        }
+        else if (flat.some(f => f.startsWith(filePath + '/'))) {
+            return {
+                type: 2,
+                ctime: -1,
+                mtime: -1,
+                size: -1,
+            };
+        }
+    }
+    async readDirectory(dirName) {
+        if (!await this.valid(dirName)) {
+            return [];
+        }
+        const pkgName = getPackageNameOfDtsPath(dirName);
+        if (!pkgName) {
+            return [];
+        }
+        if (!this.flatResults.has(pkgName)) {
+            this.flatResults.set(pkgName, this.flat(pkgName));
+        }
+        const flat = await this.flatResults.get(pkgName);
+        const dirPath = dirName.slice(`/node_modules/${pkgName}`.length);
+        const files = flat
+            .filter(f => f.substring(0, f.lastIndexOf('/')) === dirPath)
+            .map(f => f.slice(dirPath.length + 1));
+        const dirs = flat
+            .filter(f => f.startsWith(dirPath + '/') && f.substring(dirPath.length + 1).split('/').length >= 2)
+            .map(f => f.slice(dirPath.length + 1).split('/')[0]);
+        return [
+            ...files.map(f => [f, 1]),
+            ...[...new Set(dirs)].map(f => [f, 2]),
+        ];
+    }
+    async readFile(fileName) {
+        if (!await this.valid(fileName)) {
+            return;
+        }
+        if (!this.fetchResults.has(fileName)) {
+            this.fetchResults.set(fileName, this.fetchFile(fileName));
+        }
+        return await this.fetchResults.get(fileName);
+    }
+    async fetchFile(fileName) {
+        const pkgName = getPackageNameOfDtsPath(fileName);
+        if (!pkgName) {
+            return undefined;
+        }
+        if ((await this.stat(fileName))?.type !== 1) {
+            return undefined;
+        }
+        return await this.fetchText(fileName);
+    }
+    async valid(fileName) {
+        const pkgName = getPackageNameOfDtsPath(fileName);
+        if (!pkgName) {
+            return false;
+        }
+        if (pkgName.indexOf('.') >= 0 || pkgName.endsWith('/node_modules')) {
+            return false;
+        }
+        // hard code for known invalid package
+        if (pkgName.startsWith('@typescript/') || pkgName.startsWith('@types/typescript__')) {
+            return false;
+        }
+        // don't check @types if original package already having types
+        if (pkgName.startsWith('@types/')) {
+            let originalPkgName = pkgName.slice('@types/'.length);
+            if (originalPkgName.indexOf('__') >= 0) {
+                originalPkgName = '@' + originalPkgName.replace('__', '/');
+            }
+            const packageJson = await this.readFile(`/node_modules/${originalPkgName}/package.json`);
+            if (packageJson) {
+                const packageJsonObj = JSON.parse(packageJson);
+                if (packageJsonObj.types || packageJsonObj.typings) {
+                    return false;
+                }
+                const indexDts = await this.stat(`/node_modules/${originalPkgName}/index.d.ts`);
+                if (indexDts?.type === 1) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+async function fetchText(url) {
+    try {
+        const res = await fetch(url);
+        if (res.status === 200) {
+            return await res.text();
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+async function fetchJson(url) {
+    try {
+        const res = await fetch(url);
+        if (res.status === 200) {
+            return await res.json();
+        }
+    }
+    catch {
+        // ignore
+    }
+}
+function getPackageNameOfDtsPath(path) {
+    if (!path.startsWith('/node_modules/')) {
+        return undefined;
+    }
+    let pkgName = path.split('/')[2];
+    if (pkgName.startsWith('@')) {
+        if (path.split('/').length < 4) {
+            return undefined;
+        }
+        pkgName += '/' + path.split('/')[3];
+    }
+    return pkgName;
+}
+exports.getPackageNameOfDtsPath = getPackageNameOfDtsPath;
+//# sourceMappingURL=dtsHost.js.map

package/out/getProgram.d.ts

@@ -1,3 +1,3 @@
 import type * as ts from 'typescript/lib/tsserverlibrary';
 import type * as embedded from '@volar/language-core';
-export declare function getProgram(ts: typeof import('typescript/lib/tsserverlibrary'), core: embedded.LanguageContext, ls: ts.LanguageService): any;
+export declare function getProgram(ts: typeof import('typescript/lib/tsserverlibrary'), core: embedded.LanguageContext, ls: ts.LanguageService, lsHost: ts.LanguageServiceHost): any;

package/out/getProgram.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getProgram = void 0;
-function getProgram(ts, core, ls) {
+function getProgram(ts, core, ls, lsHost) {
     const proxy = {
         getRootFileNames,
         emit,
@@ -34,7 +34,7 @@ function getProgram(ts, core, ls) {
         return ls.getProgram();
     }
     function getRootFileNames() {
-        return getProgram().getRootFileNames().filter(fileName => core.typescript.languageServiceHost.fileExists?.(fileName));
+        return getProgram().getRootFileNames().filter(fileName => lsHost.fileExists?.(fileName));
     }
     // for vue-tsc --noEmit --watch
     function getBindAndCheckDiagnostics(sourceFile, cancellationToken) {
@@ -63,7 +63,7 @@ function getProgram(ts, core, ls) {
         return transformDiagnostics(getProgram().getGlobalDiagnostics(cancellationToken) ?? []);
     }
     function emit(targetSourceFile, _writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
-        const scriptResult = getProgram().emit(targetSourceFile, (core.typescript.languageServiceHost.writeFile ?? ts.sys.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
+        const scriptResult = getProgram().emit(targetSourceFile, (lsHost.writeFile ?? ts.sys.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
         return {
             emitSkipped: scriptResult.emitSkipped,
             emittedFiles: scriptResult.emittedFiles,
@@ -79,10 +79,10 @@ function getProgram(ts, core, ls) {
                 && diagnostic.length !== undefined) {
                 const [virtualFile, source] = core.virtualFiles.getVirtualFile(diagnostic.file.fileName);
                 if (virtualFile && source) {
-                    if (core.typescript.languageServiceHost.fileExists?.(source.fileName) === false)
+                    if (lsHost.fileExists?.(source.fileName) === false)
                         continue;
-                    for (const [sourceFileName, map] of core.virtualFiles.getMaps(virtualFile)) {
-                        if (sourceFileName !== source.fileName)
+                    for (const [_, [sourceSnapshot, map]] of core.virtualFiles.getMaps(virtualFile)) {
+                        if (sourceSnapshot !== source.snapshot)
                             continue;
                         for (const start of map.toSourceOffsets(diagnostic.start)) {
                             const reportStart = typeof start[1].data.diagnostic === 'object' ? typeof start[1].data.diagnostic.shouldReport() : !!start[1].data.diagnostic;
@@ -100,7 +100,7 @@ function getProgram(ts, core, ls) {
                     }
                 }
                 else {
-                    if (core.typescript.languageServiceHost.fileExists?.(diagnostic.file.fileName) === false)
+                    if (lsHost.fileExists?.(diagnostic.file.fileName) === false)
                         continue;
                     onMapping(diagnostic, diagnostic.file.fileName, diagnostic.start, diagnostic.start + diagnostic.length, diagnostic.file.text);
                 }
@@ -116,7 +116,7 @@ function getProgram(ts, core, ls) {
                 : undefined;
             if (!file) {
                 if (docText === undefined) {
-                    const snapshot = core.typescript.languageServiceHost.getScriptSnapshot(fileName);
+                    const snapshot = lsHost.getScriptSnapshot(fileName);
                     if (snapshot) {
                         docText = snapshot.getText(0, snapshot.getLength());
                     }

package/out/index.d.ts

@@ -1,8 +1,5 @@
-import type * as ts from 'typescript/lib/tsserverlibrary';
-import * as embedded from '@volar/language-core';
-export declare function createLanguageService(host: embedded.LanguageServiceHost, mods: embedded.Language[], ts: typeof import('typescript/lib/tsserverlibrary')): {
-    __internal__: {
-        languageService: ts.LanguageService;
-        context: embedded.LanguageContext;
-    };
-} & ts.LanguageService;
+export * from './documentRegistry';
+export * from './dtsHost';
+export * from './languageService';
+export * from './languageServiceHost';
+export * from './sys';

package/out/index.js

@@ -1,288 +1,22 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLanguageService = void 0;
-const getProgram_1 = require("./getProgram");
-const embedded = require("@volar/language-core");
-function createLanguageService(host, mods, ts) {
-    const core = embedded.createLanguageContext({ typescript: ts }, host, mods);
-    if (!ts) {
-        throw new Error('TypeScript module not provided.');
-    }
-    const ls = ts.createLanguageService(core.typescript.languageServiceHost);
-    return new Proxy({
-        organizeImports,
-        // only support for .ts for now, not support for .vue
-        getDefinitionAtPosition,
-        getDefinitionAndBoundSpan,
-        getTypeDefinitionAtPosition,
-        getImplementationAtPosition,
-        findRenameLocations,
-        getReferencesAtPosition,
-        findReferences,
-        // TODO: now is handled by vue server
-        // prepareCallHierarchy: tsLanguageService.rawLs.prepareCallHierarchy,
-        // provideCallHierarchyIncomingCalls: tsLanguageService.rawLs.provideCallHierarchyIncomingCalls,
-        // provideCallHierarchyOutgoingCalls: tsLanguageService.rawLs.provideCallHierarchyOutgoingCalls,
-        // getEditsForFileRename: tsLanguageService.rawLs.getEditsForFileRename,
-        // TODO
-        // getCodeFixesAtPosition: tsLanguageService.rawLs.getCodeFixesAtPosition,
-        // getCombinedCodeFix: tsLanguageService.rawLs.getCombinedCodeFix,
-        // applyCodeActionCommand: tsLanguageService.rawLs.applyCodeActionCommand,
-        // getApplicableRefactors: tsLanguageService.rawLs.getApplicableRefactors,
-        // getEditsForRefactor: tsLanguageService.rawLs.getEditsForRefactor,
-        getProgram: () => (0, getProgram_1.getProgram)(ts, core, ls),
-        __internal__: {
-            context: core,
-            languageService: ls,
-        },
-    }, {
-        get: (target, property) => {
-            if (property in target) {
-                return target[property];
-            }
-            return ls[property];
-        },
-    });
-    // apis
-    function organizeImports(args, formatOptions, preferences) {
-        let edits = [];
-        const file = core.virtualFiles.getSource(args.fileName)?.root;
-        if (file) {
-            embedded.forEachEmbeddedFile(file, embeddedFile => {
-                if (embeddedFile.kind === embedded.FileKind.TypeScriptHostFile && embeddedFile.capabilities.codeAction) {
-                    edits = edits.concat(ls.organizeImports({
-                        ...args,
-                        fileName: embeddedFile.fileName,
-                    }, formatOptions, preferences));
-                }
-            });
-        }
-        else {
-            return ls.organizeImports(args, formatOptions, preferences);
-        }
-        return edits.map(transformFileTextChanges).filter(notEmpty);
-    }
-    function getReferencesAtPosition(fileName, position) {
-        return findLocations(fileName, position, 'references');
-    }
-    function getDefinitionAtPosition(fileName, position) {
-        return findLocations(fileName, position, 'definition');
-    }
-    function getTypeDefinitionAtPosition(fileName, position) {
-        return findLocations(fileName, position, 'typeDefinition');
-    }
-    function getImplementationAtPosition(fileName, position) {
-        return findLocations(fileName, position, 'implementation');
-    }
-    function findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename) {
-        return findLocations(fileName, position, 'rename', findInStrings, findInComments, providePrefixAndSuffixTextForRename);
-    }
-    function findLocations(fileName, position, mode, findInStrings = false, findInComments = false, providePrefixAndSuffixTextForRename) {
-        const loopChecker = new Set();
-        let symbols = [];
-        withMirrors(fileName, position);
-        return symbols.map(s => transformDocumentSpanLike(s)).filter(notEmpty);
-        function withMirrors(fileName, position) {
-            if (loopChecker.has(fileName + ':' + position))
-                return;
-            loopChecker.add(fileName + ':' + position);
-            const _symbols = mode === 'definition' ? ls.getDefinitionAtPosition(fileName, position)
-                : mode === 'typeDefinition' ? ls.getTypeDefinitionAtPosition(fileName, position)
-                    : mode === 'references' ? ls.getReferencesAtPosition(fileName, position)
-                        : mode === 'implementation' ? ls.getImplementationAtPosition(fileName, position)
-                            : mode === 'rename' ? ls.findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename)
-                                : undefined;
-            if (!_symbols)
-                return;
-            symbols = symbols.concat(_symbols);
-            for (const ref of _symbols) {
-                loopChecker.add(ref.fileName + ':' + ref.textSpan.start);
-                const [virtualFile] = core.virtualFiles.getVirtualFile(ref.fileName);
-                if (!virtualFile)
-                    continue;
-                const mirrorMap = core.virtualFiles.getMirrorMap(virtualFile);
-                if (!mirrorMap)
-                    continue;
-                for (const [mirrorOffset, data] of mirrorMap.findMirrorOffsets(ref.textSpan.start)) {
-                    if ((mode === 'definition' || mode === 'typeDefinition' || mode === 'implementation') && !data.definition)
-                        continue;
-                    if ((mode === 'references') && !data.references)
-                        continue;
-                    if ((mode === 'rename') && !data.rename)
-                        continue;
-                    if (loopChecker.has(ref.fileName + ':' + mirrorOffset))
-                        continue;
-                    withMirrors(ref.fileName, mirrorOffset);
-                }
-            }
-        }
-    }
-    function getDefinitionAndBoundSpan(fileName, position) {
-        const loopChecker = new Set();
-        let textSpan;
-        let symbols = [];
-        withMirrors(fileName, position);
-        if (!textSpan)
-            return;
-        return {
-            textSpan: textSpan,
-            definitions: symbols?.map(s => transformDocumentSpanLike(s)).filter(notEmpty),
-        };
-        function withMirrors(fileName, position) {
-            if (loopChecker.has(fileName + ':' + position))
-                return;
-            loopChecker.add(fileName + ':' + position);
-            const _symbols = ls.getDefinitionAndBoundSpan(fileName, position);
-            if (!_symbols)
-                return;
-            if (!textSpan) {
-                textSpan = _symbols.textSpan;
-            }
-            if (!_symbols.definitions)
-                return;
-            symbols = symbols.concat(_symbols.definitions);
-            for (const ref of _symbols.definitions) {
-                loopChecker.add(ref.fileName + ':' + ref.textSpan.start);
-                const [virtualFile] = core.virtualFiles.getVirtualFile(ref.fileName);
-                if (!virtualFile)
-                    continue;
-                const mirrorMap = core.virtualFiles.getMirrorMap(virtualFile);
-                if (!mirrorMap)
-                    continue;
-                for (const [mirrorOffset, data] of mirrorMap.findMirrorOffsets(ref.textSpan.start)) {
-                    if (!data.definition)
-                        continue;
-                    if (loopChecker.has(ref.fileName + ':' + mirrorOffset))
-                        continue;
-                    withMirrors(ref.fileName, mirrorOffset);
-                }
-            }
-        }
-    }
-    function findReferences(fileName, position) {
-        const loopChecker = new Set();
-        let symbols = [];
-        withMirrors(fileName, position);
-        return symbols.map(s => transformReferencedSymbol(s)).filter(notEmpty);
-        function withMirrors(fileName, position) {
-            if (loopChecker.has(fileName + ':' + position))
-                return;
-            loopChecker.add(fileName + ':' + position);
-            const _symbols = ls.findReferences(fileName, position);
-            if (!_symbols)
-                return;
-            symbols = symbols.concat(_symbols);
-            for (const symbol of _symbols) {
-                for (const ref of symbol.references) {
-                    loopChecker.add(ref.fileName + ':' + ref.textSpan.start);
-                    const [virtualFile] = core.virtualFiles.getVirtualFile(ref.fileName);
-                    if (!virtualFile)
-                        continue;
-                    const mirrorMap = core.virtualFiles.getMirrorMap(virtualFile);
-                    if (!mirrorMap)
-                        continue;
-                    for (const [mirrorOffset, data] of mirrorMap.findMirrorOffsets(ref.textSpan.start)) {
-                        if (!data.references)
-                            continue;
-                        if (loopChecker.has(ref.fileName + ':' + mirrorOffset))
-                            continue;
-                        withMirrors(ref.fileName, mirrorOffset);
-                    }
-                }
-            }
-        }
-    }
-    // transforms
-    function transformFileTextChanges(changes) {
-        const [_, source] = core.virtualFiles.getVirtualFile(changes.fileName);
-        if (source) {
-            return {
-                ...changes,
-                fileName: source.fileName,
-                textChanges: changes.textChanges.map(c => {
-                    const span = transformSpan(changes.fileName, c.span);
-                    if (span) {
-                        return {
-                            ...c,
-                            span: span.textSpan,
-                        };
-                    }
-                }).filter(notEmpty),
-            };
-        }
-        else {
-            return changes;
-        }
-    }
-    function transformReferencedSymbol(symbol) {
-        const definition = transformDocumentSpanLike(symbol.definition);
-        const references = symbol.references.map(r => transformDocumentSpanLike(r)).filter(notEmpty);
-        if (definition) {
-            return {
-                definition,
-                references,
-            };
-        }
-        else if (references.length) { // TODO: remove patching
-            return {
-                definition: {
-                    ...symbol.definition,
-                    fileName: references[0].fileName,
-                    textSpan: references[0].textSpan,
-                },
-                references,
-            };
-        }
-    }
-    function transformDocumentSpanLike(documentSpan) {
-        const textSpan = transformSpan(documentSpan.fileName, documentSpan.textSpan);
-        if (!textSpan)
-            return;
-        const contextSpan = transformSpan(documentSpan.fileName, documentSpan.contextSpan);
-        const originalTextSpan = transformSpan(documentSpan.originalFileName, documentSpan.originalTextSpan);
-        const originalContextSpan = transformSpan(documentSpan.originalFileName, documentSpan.originalContextSpan);
-        return {
-            ...documentSpan,
-            fileName: textSpan.fileName,
-            textSpan: textSpan.textSpan,
-            contextSpan: contextSpan?.textSpan,
-            originalFileName: originalTextSpan?.fileName,
-            originalTextSpan: originalTextSpan?.textSpan,
-            originalContextSpan: originalContextSpan?.textSpan,
-        };
-    }
-    function transformSpan(fileName, textSpan) {
-        if (!fileName)
-            return;
-        if (!textSpan)
-            return;
-        const [virtualFile, source] = core.virtualFiles.getVirtualFile(fileName);
-        if (virtualFile && source) {
-            for (const [sourceFileName, map] of core.virtualFiles.getMaps(virtualFile)) {
-                if (source.fileName !== sourceFileName)
-                    continue;
-                const sourceLoc = map.toSourceOffset(textSpan.start);
-                if (sourceLoc) {
-                    return {
-                        fileName: source.fileName,
-                        textSpan: {
-                            start: sourceLoc[0],
-                            length: textSpan.length,
-                        },
-                    };
-                }
-            }
-        }
-        else {
-            return {
-                fileName,
-                textSpan,
-            };
-        }
-    }
-}
-exports.createLanguageService = createLanguageService;
-function notEmpty(value) {
-    return value !== null && value !== undefined;
-}
+__exportStar(require("./documentRegistry"), exports);
+__exportStar(require("./dtsHost"), exports);
+__exportStar(require("./languageService"), exports);
+__exportStar(require("./languageServiceHost"), exports);
+__exportStar(require("./sys"), exports);
 //# sourceMappingURL=index.js.map

package/out/languageService.d.ts

@@ -0,0 +1,9 @@
+import { LanguageContext } from '@volar/language-core';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function createLanguageService(core: LanguageContext, ts: typeof import('typescript/lib/tsserverlibrary'), sys: ts.System): {
+    __internal__: {
+        languageServiceHost: ts.LanguageServiceHost;
+        languageService: ts.LanguageService;
+        context: LanguageContext;
+    };
+} & ts.LanguageService;