@volar/language-core 1.0.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Johnson Chu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/out/documentRegistry.d.ts

@@ -0,0 +1,46 @@
+import type { EmbeddedFile, EmbeddedLanguageModule, DocumentCapabilities, PositionCapabilities, SourceFile } from './types';
+import { Teleport } from './sourceMaps';
+import { Mapping, SourceMapBase } from '@volar/source-map';
+export declare function forEachEmbeddeds(input: EmbeddedFile[], cb: (embedded: EmbeddedFile) => void): void;
+export declare type DocumentRegistry = ReturnType<typeof createDocumentRegistry>;
+export declare function createDocumentRegistry(): {
+    get: (fileName: string) => [SourceFile, EmbeddedLanguageModule] | undefined;
+    delete: (fileName: string) => boolean;
+    has: (fileName: string) => boolean;
+    set: (fileName: string, vueFile: SourceFile, languageModule: EmbeddedLanguageModule) => [SourceFile, EmbeddedLanguageModule<SourceFile>];
+    getFileNames: () => string[];
+    getAll: () => [SourceFile, EmbeddedLanguageModule<SourceFile>][];
+    getTeleport: (fileName: string) => Teleport | undefined;
+    getAllEmbeddeds: () => Generator<{
+        vueFile: SourceFile;
+        embedded: EmbeddedFile;
+    }, void, unknown>;
+    fromEmbeddedLocation: (fileName: string, start: number, end?: number, filter?: ((data: PositionCapabilities) => boolean) | undefined, sourceMapFilter?: ((sourceMap: DocumentCapabilities) => boolean) | undefined) => Generator<{
+        fileName: string;
+        range: {
+            start: number;
+            end: number;
+        };
+        mapped: {
+            vueFile: SourceFile;
+            embedded: EmbeddedFile;
+        };
+        data: any;
+    } | {
+        fileName: string;
+        range: {
+            start: number;
+            end: number;
+        };
+        mapped?: undefined;
+        data?: undefined;
+    }, void, unknown>;
+    fromEmbeddedFile: (file: EmbeddedFile) => SourceFile | undefined;
+    fromEmbeddedFileName: (fileName: string) => {
+        vueFile: SourceFile;
+        embedded: EmbeddedFile;
+    } | undefined;
+    getSourceMap: (file: SourceFile, mappings: Mapping<any>[]) => SourceMapBase<any>;
+    getTeleportSourceMap: (file: SourceFile, mappings: Mapping<any>[]) => Teleport;
+    onSourceFileUpdated(file: SourceFile): void;
+};

package/out/documentRegistry.js

@@ -0,0 +1,139 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDocumentRegistry = exports.forEachEmbeddeds = void 0;
+const reactivity_1 = require("@vue/reactivity");
+const sourceMaps_1 = require("./sourceMaps");
+const source_map_1 = require("@volar/source-map");
+function forEachEmbeddeds(input, cb) {
+    for (const child of input) {
+        if (child) {
+            cb(child);
+        }
+        forEachEmbeddeds(child.embeddeds, cb);
+    }
+}
+exports.forEachEmbeddeds = forEachEmbeddeds;
+function createDocumentRegistry() {
+    const files = (0, reactivity_1.shallowReactive)({});
+    const all = (0, reactivity_1.computed)(() => Object.values(files));
+    const fileNames = (0, reactivity_1.computed)(() => all.value.map(sourceFile => sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile[0].fileName));
+    const embeddedDocumentsMap = (0, reactivity_1.computed)(() => {
+        const map = new WeakMap();
+        for (const [sourceFile] of all.value) {
+            forEachEmbeddeds(sourceFile.embeddeds, embedded => {
+                map.set(embedded, sourceFile);
+            });
+        }
+        return map;
+    });
+    const sourceMapsByFileName = (0, reactivity_1.computed)(() => {
+        const map = new Map();
+        for (const [sourceFile] of all.value) {
+            forEachEmbeddeds(sourceFile.embeddeds, embedded => {
+                map.set(normalizePath(embedded.fileName), { vueFile: sourceFile, embedded });
+            });
+        }
+        return map;
+    });
+    const teleports = (0, reactivity_1.computed)(() => {
+        const map = new Map();
+        for (const key in files) {
+            const [sourceFile] = files[key];
+            forEachEmbeddeds(sourceFile.embeddeds, embedded => {
+                if (embedded.teleportMappings) {
+                    map.set(normalizePath(embedded.fileName), getTeleport(sourceFile, embedded.teleportMappings));
+                }
+            });
+        }
+        return map;
+    });
+    const _sourceMaps = new WeakMap();
+    const _teleports = new WeakMap();
+    return {
+        get: (fileName) => files[normalizePath(fileName)],
+        delete: (fileName) => delete files[normalizePath(fileName)],
+        has: (fileName) => !!files[normalizePath(fileName)],
+        set: (fileName, vueFile, languageModule) => files[normalizePath(fileName)] = [vueFile, languageModule],
+        getFileNames: () => fileNames.value,
+        getAll: () => all.value,
+        getTeleport: (fileName) => teleports.value.get(normalizePath(fileName)),
+        getAllEmbeddeds: function* () {
+            for (const sourceMap of sourceMapsByFileName.value) {
+                yield sourceMap[1];
+            }
+        },
+        fromEmbeddedLocation: function* (fileName, start, end, filter, sourceMapFilter) {
+            if (fileName.endsWith('/__VLS_types.ts')) { // TODO: monkey fix
+                return;
+            }
+            if (end === undefined)
+                end = start;
+            const mapped = sourceMapsByFileName.value.get(normalizePath(fileName));
+            if (mapped) {
+                if (sourceMapFilter && !sourceMapFilter(mapped.embedded.capabilities))
+                    return;
+                const sourceMap = getSourceMap(mapped.vueFile, mapped.embedded.mappings);
+                for (const vueRange of sourceMap.getSourceRanges(start, end, filter)) {
+                    yield {
+                        fileName: mapped.vueFile.fileName,
+                        range: vueRange[0],
+                        mapped: mapped,
+                        data: vueRange[1],
+                    };
+                }
+            }
+            else {
+                yield {
+                    fileName,
+                    range: {
+                        start,
+                        end,
+                    },
+                };
+            }
+        },
+        fromEmbeddedFile: function (file) {
+            return embeddedDocumentsMap.value.get(file);
+        },
+        fromEmbeddedFileName: function (fileName) {
+            return sourceMapsByFileName.value.get(normalizePath(fileName));
+        },
+        getSourceMap,
+        getTeleportSourceMap: getTeleport,
+        // TODO: unuse this
+        onSourceFileUpdated(file) {
+            _sourceMaps.delete(file);
+            _teleports.delete(file);
+        },
+    };
+    function getSourceMap(file, mappings) {
+        let map1 = _sourceMaps.get(file);
+        if (!map1) {
+            map1 = new WeakMap();
+            _sourceMaps.set(file, map1);
+        }
+        let map2 = map1.get(mappings);
+        if (!map2) {
+            map2 = new source_map_1.SourceMapBase(mappings);
+            map1.set(mappings, map2);
+        }
+        return map2;
+    }
+    function getTeleport(file, mappings) {
+        let map1 = _teleports.get(file);
+        if (!map1) {
+            map1 = new WeakMap();
+            _teleports.set(file, map1);
+        }
+        let map2 = map1.get(mappings);
+        if (!map2) {
+            map2 = new sourceMaps_1.Teleport(mappings);
+            map1.set(mappings, map2);
+        }
+        return map2;
+    }
+}
+exports.createDocumentRegistry = createDocumentRegistry;
+function normalizePath(fileName) {
+    return fileName.replace(/\\/g, '/').toLowerCase();
+}
+//# sourceMappingURL=documentRegistry.js.map

package/out/index.d.ts

@@ -0,0 +1,4 @@
+export * from './documentRegistry';
+export * from './languageContext';
+export * from './sourceMaps';
+export * from './types';

package/out/index.js

@@ -0,0 +1,20 @@
+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 });
+__exportStar(require("./documentRegistry"), exports);
+__exportStar(require("./languageContext"), exports);
+__exportStar(require("./sourceMaps"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/out/languageContext.d.ts

@@ -0,0 +1,47 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { EmbeddedLanguageModule, SourceFile, LanguageServiceHost } from './types';
+export declare type EmbeddedLanguageContext = ReturnType<typeof createEmbeddedLanguageServiceHost>;
+export declare function createEmbeddedLanguageServiceHost(host: LanguageServiceHost, languageModules: EmbeddedLanguageModule[]): {
+    typescriptLanguageServiceHost: ts.LanguageServiceHost;
+    mapper: {
+        get: (fileName: string) => [SourceFile, EmbeddedLanguageModule<SourceFile>] | undefined;
+        delete: (fileName: string) => boolean;
+        has: (fileName: string) => boolean;
+        set: (fileName: string, vueFile: SourceFile, languageModule: EmbeddedLanguageModule<SourceFile>) => [SourceFile, EmbeddedLanguageModule<SourceFile>];
+        getFileNames: () => string[];
+        getAll: () => [SourceFile, EmbeddedLanguageModule<SourceFile>][];
+        getTeleport: (fileName: string) => import("./sourceMaps").Teleport | undefined;
+        getAllEmbeddeds: () => Generator<{
+            vueFile: SourceFile;
+            embedded: import("./types").EmbeddedFile;
+        }, void, unknown>;
+        fromEmbeddedLocation: (fileName: string, start: number, end?: number | undefined, filter?: ((data: import("./types").PositionCapabilities) => boolean) | undefined, sourceMapFilter?: ((sourceMap: import("./types").DocumentCapabilities) => boolean) | undefined) => Generator<{
+            fileName: string;
+            range: {
+                start: number;
+                end: number;
+            };
+            mapped: {
+                vueFile: SourceFile;
+                embedded: import("./types").EmbeddedFile;
+            };
+            data: any;
+        } | {
+            fileName: string;
+            range: {
+                start: number;
+                end: number;
+            };
+            mapped?: undefined;
+            data?: undefined;
+        }, void, unknown>;
+        fromEmbeddedFile: (file: import("./types").EmbeddedFile) => SourceFile | undefined;
+        fromEmbeddedFileName: (fileName: string) => {
+            vueFile: SourceFile;
+            embedded: import("./types").EmbeddedFile;
+        } | undefined;
+        getSourceMap: (file: SourceFile, mappings: import("@volar/source-map").Mapping<any>[]) => import("@volar/source-map").SourceMapBase<any>;
+        getTeleportSourceMap: (file: SourceFile, mappings: import("@volar/source-map").Mapping<any>[]) => import("./sourceMaps").Teleport;
+        onSourceFileUpdated(file: SourceFile): void;
+    };
+};

package/out/languageContext.js

@@ -0,0 +1,258 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmbeddedLanguageServiceHost = void 0;
+const path_1 = require("path");
+const documentRegistry_1 = require("./documentRegistry");
+const reactivity_1 = require("@vue/reactivity");
+function createEmbeddedLanguageServiceHost(host, languageModules) {
+    for (const languageModule of languageModules.reverse()) {
+        if (languageModule.proxyLanguageServiceHost) {
+            const proxyApis = languageModule.proxyLanguageServiceHost(host);
+            host = new Proxy(host, {
+                get(target, key) {
+                    if (key in proxyApis) {
+                        return proxyApis[key];
+                    }
+                    return target[key];
+                },
+            });
+        }
+    }
+    let lastProjectVersion;
+    let tsProjectVersion = 0;
+    const documentRegistry = (0, documentRegistry_1.createDocumentRegistry)();
+    const ts = host.getTypeScriptModule();
+    const tsFileVersions = new Map();
+    const scriptSnapshots = new Map();
+    const fileVersions = new Map();
+    const _tsHost = {
+        fileExists: host.fileExists
+            ? fileName => {
+                var _a;
+                // .vue.js -> .vue
+                // .vue.ts -> .vue
+                // .vue.d.ts (never)
+                const vueFileName = fileName.substring(0, fileName.lastIndexOf('.'));
+                if (!documentRegistry.get(vueFileName)) {
+                    // create virtual files
+                    const scriptSnapshot = host.getScriptSnapshot(vueFileName);
+                    if (scriptSnapshot) {
+                        for (const langaugeModule of languageModules) {
+                            const sourceFile = langaugeModule.createSourceFile(vueFileName, scriptSnapshot);
+                            if (sourceFile) {
+                                documentRegistry.set(vueFileName, (0, reactivity_1.shallowReactive)(sourceFile), langaugeModule);
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (!!documentRegistry.fromEmbeddedFileName(fileName)) {
+                    return true;
+                }
+                return !!((_a = host.fileExists) === null || _a === void 0 ? void 0 : _a.call(host, fileName));
+            }
+            : undefined,
+        getProjectVersion: () => {
+            return tsProjectVersion.toString();
+        },
+        getScriptFileNames,
+        getScriptVersion,
+        getScriptSnapshot,
+        readDirectory: (_path, extensions, exclude, include, depth) => {
+            var _a, _b;
+            const result = (_b = (_a = host.readDirectory) === null || _a === void 0 ? void 0 : _a.call(host, _path, extensions, exclude, include, depth)) !== null && _b !== void 0 ? _b : [];
+            for (const vuePath of documentRegistry.getFileNames()) {
+                const vuePath2 = path_1.posix.join(_path, path_1.posix.basename(vuePath));
+                if (path_1.posix.relative(_path.toLowerCase(), vuePath.toLowerCase()).startsWith('..')) {
+                    continue;
+                }
+                if (!depth && vuePath.toLowerCase() === vuePath2.toLowerCase()) {
+                    result.push(vuePath2);
+                }
+                else if (depth) {
+                    result.push(vuePath2); // TODO: depth num
+                }
+            }
+            return result;
+        },
+        getScriptKind(fileName) {
+            if (documentRegistry.has(fileName))
+                return ts.ScriptKind.TSX; // can't use External, Unknown
+            switch (path_1.posix.extname(fileName)) {
+                case '.js': return ts.ScriptKind.JS;
+                case '.jsx': return ts.ScriptKind.JSX;
+                case '.ts': return ts.ScriptKind.TS;
+                case '.tsx': return ts.ScriptKind.TSX;
+                case '.json': return ts.ScriptKind.JSON;
+                default: return ts.ScriptKind.Unknown;
+            }
+        },
+    };
+    return {
+        typescriptLanguageServiceHost: new Proxy(_tsHost, {
+            get: (target, property) => {
+                update();
+                return target[property] || host[property];
+            },
+        }),
+        mapper: new Proxy(documentRegistry, {
+            get: (target, property) => {
+                update();
+                return target[property];
+            },
+        }),
+    };
+    function update() {
+        var _a;
+        const newProjectVersion = (_a = host.getProjectVersion) === null || _a === void 0 ? void 0 : _a.call(host);
+        const sholdUpdate = newProjectVersion === undefined || newProjectVersion !== lastProjectVersion;
+        lastProjectVersion = newProjectVersion;
+        if (!sholdUpdate)
+            return;
+        let tsFileUpdated = false;
+        const remainFileNames = new Set(host.getScriptFileNames());
+        const sourceFilesToUpdate = [];
+        // .vue
+        for (const [sourceFile, languageModule] of documentRegistry.getAll()) {
+            remainFileNames.delete(sourceFile.fileName);
+            const newVersion = host.getScriptVersion(sourceFile.fileName);
+            if (fileVersions.get(sourceFile.fileName) !== newVersion) {
+                fileVersions.set(sourceFile.fileName, newVersion);
+                const snapshot = host.getScriptSnapshot(sourceFile.fileName);
+                if (snapshot) {
+                    // update
+                    sourceFilesToUpdate.push([sourceFile, languageModule, snapshot]);
+                }
+                else {
+                    // delete
+                    if (documentRegistry.delete(sourceFile.fileName)) {
+                        tsFileUpdated = true;
+                    }
+                }
+            }
+        }
+        // add
+        for (const fileName of [...remainFileNames]) {
+            const snapshot = host.getScriptSnapshot(fileName);
+            if (snapshot) {
+                for (const languageModule of languageModules) {
+                    const sourceFile = languageModule.createSourceFile(fileName, snapshot);
+                    if (sourceFile) {
+                        documentRegistry.set(fileName, (0, reactivity_1.shallowReactive)(sourceFile), languageModule);
+                        remainFileNames.delete(fileName);
+                        break;
+                    }
+                }
+            }
+        }
+        // .ts / .js / .d.ts / .json ...
+        for (const [oldTsFileName, oldTsFileVersion] of [...tsFileVersions]) {
+            const newVersion = host.getScriptVersion(oldTsFileName);
+            if (oldTsFileVersion !== newVersion) {
+                if (!remainFileNames.has(oldTsFileName) && !host.getScriptSnapshot(oldTsFileName)) {
+                    // delete
+                    tsFileVersions.delete(oldTsFileName);
+                }
+                else {
+                    // update
+                    tsFileVersions.set(oldTsFileName, newVersion);
+                }
+                tsFileUpdated = true;
+            }
+        }
+        for (const nowFileName of remainFileNames) {
+            if (!tsFileVersions.has(nowFileName)) {
+                // add
+                const newVersion = host.getScriptVersion(nowFileName);
+                tsFileVersions.set(nowFileName, newVersion);
+                tsFileUpdated = true;
+            }
+        }
+        for (const [sourceFile, languageModule, snapshot] of sourceFilesToUpdate) {
+            (0, documentRegistry_1.forEachEmbeddeds)(sourceFile.embeddeds, embedded => {
+                fileVersions.delete(embedded.fileName);
+            });
+            const oldScripts = {};
+            const newScripts = {};
+            if (!tsFileUpdated) {
+                (0, documentRegistry_1.forEachEmbeddeds)(sourceFile.embeddeds, embedded => {
+                    if (embedded.isTsHostFile) {
+                        oldScripts[embedded.fileName] = embedded.text;
+                    }
+                });
+            }
+            languageModule.updateSourceFile(sourceFile, snapshot);
+            documentRegistry.onSourceFileUpdated(sourceFile);
+            if (!tsFileUpdated) {
+                (0, documentRegistry_1.forEachEmbeddeds)(sourceFile.embeddeds, embedded => {
+                    if (embedded.isTsHostFile) {
+                        newScripts[embedded.fileName] = embedded.text;
+                    }
+                });
+            }
+            if (!tsFileUpdated
+                && Object.keys(oldScripts).length !== Object.keys(newScripts).length
+                || Object.keys(oldScripts).some(fileName => oldScripts[fileName] !== newScripts[fileName])) {
+                tsFileUpdated = true;
+            }
+        }
+        if (tsFileUpdated) {
+            tsProjectVersion++;
+        }
+    }
+    function getScriptFileNames() {
+        const tsFileNames = [];
+        for (const mapped of documentRegistry.getAllEmbeddeds()) {
+            if (mapped.embedded.isTsHostFile) {
+                tsFileNames.push(mapped.embedded.fileName); // virtual .ts
+            }
+        }
+        for (const fileName of host.getScriptFileNames()) {
+            if (host.isTsPlugin) {
+                tsFileNames.push(fileName); // .vue + .ts
+            }
+            else if (!documentRegistry.has(fileName)) {
+                tsFileNames.push(fileName); // .ts
+            }
+        }
+        return tsFileNames;
+    }
+    function getScriptVersion(fileName) {
+        var _a, _b, _c;
+        let mapped = documentRegistry.fromEmbeddedFileName(fileName);
+        if (mapped) {
+            if (fileVersions.has(mapped.embedded.fileName)) {
+                return fileVersions.get(mapped.embedded.fileName);
+            }
+            else {
+                let version = (_c = (_b = (_a = ts.sys) === null || _a === void 0 ? void 0 : _a.createHash) === null || _b === void 0 ? void 0 : _b.call(_a, mapped.embedded.text)) !== null && _c !== void 0 ? _c : mapped.embedded.text;
+                if (host.isTsc) {
+                    // fix https://github.com/johnsoncodehk/volar/issues/1082
+                    version = host.getScriptVersion(mapped.vueFile.fileName) + ':' + version;
+                }
+                fileVersions.set(mapped.embedded.fileName, version);
+                return version;
+            }
+        }
+        return host.getScriptVersion(fileName);
+    }
+    function getScriptSnapshot(fileName) {
+        const version = getScriptVersion(fileName);
+        const cache = scriptSnapshots.get(fileName.toLowerCase());
+        if (cache && cache[0] === version) {
+            return cache[1];
+        }
+        const mapped = documentRegistry.fromEmbeddedFileName(fileName);
+        if (mapped) {
+            const snapshot = ts.ScriptSnapshot.fromString(mapped.embedded.text);
+            scriptSnapshots.set(fileName.toLowerCase(), [version, snapshot]);
+            return snapshot;
+        }
+        let tsScript = host.getScriptSnapshot(fileName);
+        if (tsScript) {
+            scriptSnapshots.set(fileName.toLowerCase(), [version, tsScript]);
+            return tsScript;
+        }
+    }
+}
+exports.createEmbeddedLanguageServiceHost = createEmbeddedLanguageServiceHost;
+//# sourceMappingURL=languageContext.js.map

package/out/sourceMaps.d.ts

@@ -0,0 +1,10 @@
+import * as SourceMaps from '@volar/source-map';
+import { PositionCapabilities, TeleportMappingData, TeleportCapabilities } from './types';
+export declare class EmbeddedFileSourceMap extends SourceMaps.SourceMapBase<PositionCapabilities> {
+}
+export declare class Teleport extends SourceMaps.SourceMapBase<TeleportMappingData> {
+    findTeleports(start: number, end?: number, filter?: (data: TeleportCapabilities) => boolean): Generator<readonly [{
+        start: number;
+        end: number;
+    }, TeleportCapabilities], void, unknown>;
+}

package/out/sourceMaps.js

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Teleport = exports.EmbeddedFileSourceMap = void 0;
+const SourceMaps = require("@volar/source-map");
+class EmbeddedFileSourceMap extends SourceMaps.SourceMapBase {
+}
+exports.EmbeddedFileSourceMap = EmbeddedFileSourceMap;
+class Teleport extends SourceMaps.SourceMapBase {
+    *findTeleports(start, end, filter) {
+        for (const [teleRange, data] of this.getMappedRanges(start, end, filter ? data => filter(data.toGenedCapabilities) : undefined)) {
+            yield [teleRange, data.toGenedCapabilities];
+        }
+        for (const [teleRange, data] of this.getSourceRanges(start, end, filter ? data => filter(data.toGenedCapabilities) : undefined)) {
+            yield [teleRange, data.toGenedCapabilities];
+        }
+    }
+}
+exports.Teleport = Teleport;
+//# sourceMappingURL=sourceMaps.js.map

package/out/types.d.ts

@@ -0,0 +1,65 @@
+import { Mapping } from '@volar/source-map';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export interface DocumentCapabilities {
+    diagnostics?: boolean;
+    foldingRanges?: boolean;
+    formatting?: boolean | {
+        initialIndentBracket?: [string, string];
+    };
+    documentSymbol?: boolean;
+    codeActions?: boolean;
+    inlayHints?: boolean;
+}
+export interface PositionCapabilities {
+    hover?: boolean;
+    references?: boolean;
+    definitions?: boolean;
+    rename?: boolean | {
+        normalize?(newName: string): string;
+        apply?(oldName: string, newName: string): string;
+    };
+    completion?: boolean | {
+        additional: boolean;
+    };
+    diagnostic?: boolean;
+    semanticTokens?: boolean;
+    referencesCodeLens?: boolean;
+    displayWithLink?: boolean;
+}
+export interface TeleportCapabilities {
+    references?: boolean;
+    definitions?: boolean;
+    rename?: boolean;
+}
+export interface TeleportMappingData {
+    toSourceCapabilities: TeleportCapabilities;
+    toGenedCapabilities: TeleportCapabilities;
+}
+export interface TextRange {
+    start: number;
+    end: number;
+}
+export interface SourceFile {
+    fileName: string;
+    text: string;
+    embeddeds: EmbeddedFile[];
+}
+export interface EmbeddedFile {
+    fileName: string;
+    text: string;
+    isTsHostFile: boolean;
+    capabilities: DocumentCapabilities;
+    mappings: Mapping<PositionCapabilities>[];
+    teleportMappings?: Mapping<TeleportMappingData>[];
+    embeddeds: EmbeddedFile[];
+}
+export interface EmbeddedLanguageModule<T extends SourceFile = SourceFile> {
+    createSourceFile(fileName: string, snapshot: ts.IScriptSnapshot): T | undefined;
+    updateSourceFile(sourceFile: T, snapshot: ts.IScriptSnapshot): void;
+    proxyLanguageServiceHost?(host: LanguageServiceHost): Partial<LanguageServiceHost>;
+}
+export declare type LanguageServiceHost = ts.LanguageServiceHost & {
+    getTypeScriptModule(): typeof import('typescript/lib/tsserverlibrary');
+    isTsPlugin?: boolean;
+    isTsc?: boolean;
+};

package/out/types.js

@@ -0,0 +1,2 @@
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,20 @@
+{
+	"name": "@volar/language-core",
+	"version": "1.0.0-alpha.0",
+	"main": "out/index.js",
+	"license": "MIT",
+	"files": [
+		"out/**/*.js",
+		"out/**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/johnsoncodehk/volar.git",
+		"directory": "packages/language-core"
+	},
+	"dependencies": {
+		"@volar/code-gen": "1.0.0-alpha.0",
+		"@volar/source-map": "1.0.0-alpha.0",
+		"@vue/reactivity": "^3.2.38"
+	}
+}