init

node_modules/@volar/language-core/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.

node_modules/@volar/language-core/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/virtualFiles';
+export * from './lib/languageContext';
+export * from './lib/sourceMaps';
+export * from './lib/types';
+//# sourceMappingURL=index.d.ts.map

node_modules/@volar/language-core/index.js

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

node_modules/@volar/language-core/lib/languageContext.d.ts

@@ -0,0 +1,9 @@
+import { createVirtualFiles } from './virtualFiles';
+import { Language, TypeScriptLanguageHost } from './types';
+export interface LanguageContext {
+    rawHost: TypeScriptLanguageHost;
+    host: TypeScriptLanguageHost;
+    virtualFiles: ReturnType<typeof createVirtualFiles>;
+}
+export declare function createLanguageContext(rawHost: TypeScriptLanguageHost, languages: Language<any>[]): LanguageContext;
+//# sourceMappingURL=languageContext.d.ts.map

node_modules/@volar/language-core/lib/languageContext.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguageContext = void 0;
+const virtualFiles_1 = require("./virtualFiles");
+function createLanguageContext(rawHost, languages) {
+    let host = rawHost;
+    let lastRootFiles = new Map();
+    let lastProjectVersion;
+    const virtualFiles = (0, virtualFiles_1.createVirtualFiles)(languages);
+    for (const language of languages.reverse()) {
+        if (language.resolveHost) {
+            const pastHost = host;
+            let proxyHost = language.resolveHost(host);
+            if (proxyHost === pastHost) {
+                console.warn(`[volar] language.resolveHost() should not return the same host instance.`);
+                proxyHost = { ...proxyHost };
+            }
+            host = new Proxy(proxyHost, {
+                get(target, p) {
+                    if (p in target) {
+                        return target[p];
+                    }
+                    return pastHost[p];
+                }
+            });
+        }
+    }
+    return {
+        rawHost,
+        host,
+        virtualFiles: new Proxy(virtualFiles, {
+            get: (target, property) => {
+                syncVirtualFiles();
+                return target[property];
+            },
+        }),
+    };
+    function syncVirtualFiles() {
+        const newProjectVersion = host.getProjectVersion();
+        const shouldUpdate = newProjectVersion !== lastProjectVersion;
+        if (!shouldUpdate)
+            return;
+        const nowRootFiles = new Map();
+        const remainRootFiles = new Set(lastRootFiles.keys());
+        for (const rootFileName of host.getScriptFileNames()) {
+            nowRootFiles.set(rootFileName, host.getScriptSnapshot(rootFileName));
+        }
+        for (const [fileName, snapshot] of nowRootFiles) {
+            remainRootFiles.delete(fileName);
+            if (lastRootFiles.get(fileName) !== nowRootFiles.get(fileName)) {
+                if (snapshot) {
+                    virtualFiles.updateSource(fileName, snapshot, host.getLanguageId?.(fileName));
+                }
+                else {
+                    virtualFiles.deleteSource(fileName);
+                }
+            }
+        }
+        for (const fileName of remainRootFiles) {
+            virtualFiles.deleteSource(fileName);
+        }
+        lastRootFiles = nowRootFiles;
+        lastProjectVersion = newProjectVersion;
+    }
+}
+exports.createLanguageContext = createLanguageContext;
+//# sourceMappingURL=languageContext.js.map

node_modules/@volar/language-core/lib/sourceMaps.d.ts

@@ -0,0 +1,6 @@
+import * as SourceMaps from '@volar/source-map';
+import { MirrorBehaviorCapabilities } from './types';
+export declare class MirrorMap extends SourceMaps.SourceMap<[MirrorBehaviorCapabilities, MirrorBehaviorCapabilities]> {
+    findMirrorOffsets(start: number): Generator<readonly [number, MirrorBehaviorCapabilities], void, unknown>;
+}
+//# sourceMappingURL=sourceMaps.d.ts.map

node_modules/@volar/language-core/lib/sourceMaps.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MirrorMap = void 0;
+const SourceMaps = require("@volar/source-map");
+class MirrorMap extends SourceMaps.SourceMap {
+    *findMirrorOffsets(start) {
+        for (const mapped of this.toGeneratedOffsets(start)) {
+            yield [mapped[0], mapped[1].data[1]];
+        }
+        for (const mapped of this.toSourceOffsets(start)) {
+            yield [mapped[0], mapped[1].data[0]];
+        }
+    }
+}
+exports.MirrorMap = MirrorMap;
+//# sourceMappingURL=sourceMaps.js.map

node_modules/@volar/language-core/lib/types.d.ts

@@ -0,0 +1,76 @@
+import { Mapping, Stack } from '@volar/source-map';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export interface FileCapabilities {
+    diagnostic?: boolean;
+    foldingRange?: boolean;
+    documentFormatting?: boolean;
+    documentSymbol?: boolean;
+    codeAction?: boolean;
+    inlayHint?: boolean;
+}
+export interface FileRangeCapabilities {
+    hover?: boolean;
+    references?: boolean;
+    definition?: boolean;
+    rename?: boolean | {
+        normalize?(newName: string): string;
+        apply?(newName: string): string;
+    };
+    completion?: boolean | {
+        additional?: boolean;
+        autoImportOnly?: boolean;
+    };
+    diagnostic?: boolean | {
+        shouldReport(): boolean;
+    };
+    semanticTokens?: boolean;
+    referencesCodeLens?: boolean;
+    displayWithLink?: boolean;
+}
+export interface MirrorBehaviorCapabilities {
+    references?: boolean;
+    definition?: boolean;
+    rename?: boolean;
+}
+export declare namespace FileCapabilities {
+    const full: FileCapabilities;
+}
+export declare namespace FileRangeCapabilities {
+    const full: FileRangeCapabilities;
+}
+export declare namespace MirrorBehaviorCapabilities {
+    const full: MirrorBehaviorCapabilities;
+}
+export declare enum FileKind {
+    TextFile = 0,
+    TypeScriptHostFile = 1
+}
+export interface VirtualFile {
+    fileName: string;
+    snapshot: ts.IScriptSnapshot;
+    kind: FileKind;
+    capabilities: FileCapabilities;
+    mappings: Mapping<FileRangeCapabilities>[];
+    codegenStacks: Stack[];
+    mirrorBehaviorMappings?: Mapping<[MirrorBehaviorCapabilities, MirrorBehaviorCapabilities]>[];
+    embeddedFiles: VirtualFile[];
+}
+export interface Language<T extends VirtualFile = VirtualFile> {
+    resolveHost?(host: TypeScriptLanguageHost): TypeScriptLanguageHost;
+    createVirtualFile(fileName: string, snapshot: ts.IScriptSnapshot, languageId: string | undefined): T | undefined;
+    updateVirtualFile(virtualFile: T, snapshot: ts.IScriptSnapshot): void;
+    deleteVirtualFile?(virtualFile: T): void;
+}
+interface LanguageHost {
+    workspacePath: string;
+    rootPath: string;
+    getProjectVersion(): string;
+    getScriptFileNames(): string[];
+    getScriptSnapshot(fileName: string): ts.IScriptSnapshot | undefined;
+    getLanguageId?(fileName: string): string | undefined;
+}
+export interface TypeScriptLanguageHost extends LanguageHost, Pick<ts.LanguageServiceHost, 'getCancellationToken' | 'getLocalizedDiagnosticMessages' | 'getCompilationSettings' | 'getProjectReferences'> {
+    resolveModuleName?(path: string, impliedNodeFormat?: ts.ResolutionMode): string;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

node_modules/@volar/language-core/lib/types.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileKind = exports.MirrorBehaviorCapabilities = exports.FileRangeCapabilities = exports.FileCapabilities = void 0;
+var FileCapabilities;
+(function (FileCapabilities) {
+    FileCapabilities.full = {
+        diagnostic: true,
+        foldingRange: true,
+        documentFormatting: true,
+        documentSymbol: true,
+        codeAction: true,
+        inlayHint: true,
+    };
+})(FileCapabilities || (exports.FileCapabilities = FileCapabilities = {}));
+var FileRangeCapabilities;
+(function (FileRangeCapabilities) {
+    FileRangeCapabilities.full = {
+        hover: true,
+        references: true,
+        definition: true,
+        rename: true,
+        completion: true,
+        diagnostic: true,
+        semanticTokens: true,
+    };
+})(FileRangeCapabilities || (exports.FileRangeCapabilities = FileRangeCapabilities = {}));
+var MirrorBehaviorCapabilities;
+(function (MirrorBehaviorCapabilities) {
+    MirrorBehaviorCapabilities.full = {
+        references: true,
+        definition: true,
+        rename: true,
+    };
+})(MirrorBehaviorCapabilities || (exports.MirrorBehaviorCapabilities = MirrorBehaviorCapabilities = {}));
+var FileKind;
+(function (FileKind) {
+    FileKind[FileKind["TextFile"] = 0] = "TextFile";
+    FileKind[FileKind["TypeScriptHostFile"] = 1] = "TypeScriptHostFile";
+})(FileKind || (exports.FileKind = FileKind = {}));
+//# sourceMappingURL=types.js.map

node_modules/@volar/language-core/lib/virtualFiles.d.ts

@@ -0,0 +1,26 @@
+import { SourceMap } from '@volar/source-map';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { MirrorMap } from './sourceMaps';
+import type { FileRangeCapabilities, Language, VirtualFile } from './types';
+export type VirtualFiles = ReturnType<typeof createVirtualFiles>;
+export interface Source {
+    fileName: string;
+    languageId: string | undefined;
+    snapshot: ts.IScriptSnapshot;
+    root: VirtualFile;
+    language: Language;
+}
+export declare function createVirtualFiles(languages: Language[]): {
+    allSources(): Source[];
+    updateSource(fileName: string, snapshot: ts.IScriptSnapshot, languageId: string | undefined): VirtualFile | undefined;
+    deleteSource(fileName: string): void;
+    getSource(fileName: string): Source | undefined;
+    hasSource: (fileName: string) => boolean;
+    getMirrorMap: (file: VirtualFile) => MirrorMap | undefined;
+    getMaps: (virtualFile: VirtualFile) => Map<string, [ts.IScriptSnapshot, SourceMap<FileRangeCapabilities>]>;
+    hasVirtualFile(fileName: string): boolean;
+    getVirtualFile(fileName: string): readonly [VirtualFile, Source] | readonly [undefined, undefined];
+};
+export declare function updateVirtualFileMaps(virtualFile: VirtualFile, getSourceSnapshot: (source: string | undefined) => [string, ts.IScriptSnapshot] | undefined, map?: Map<string, [ts.IScriptSnapshot, SourceMap<FileRangeCapabilities>]>): Map<string, [ts.IScriptSnapshot, SourceMap<FileRangeCapabilities>]>;
+export declare function forEachEmbeddedFile(file: VirtualFile, cb: (embedded: VirtualFile) => void): void;
+//# sourceMappingURL=virtualFiles.d.ts.map

node_modules/@volar/language-core/lib/virtualFiles.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachEmbeddedFile = exports.updateVirtualFileMaps = exports.createVirtualFiles = void 0;
+const source_map_1 = require("@volar/source-map");
+const sourceMaps_1 = require("./sourceMaps");
+function createVirtualFiles(languages) {
+    const sourceFiles = new Map();
+    const virtualFiles = new Map();
+    const virtualFileMaps = new WeakMap();
+    const virtualFileToMirrorMap = new WeakMap();
+    return {
+        allSources() {
+            return Array.from(sourceFiles.values());
+        },
+        updateSource(fileName, snapshot, languageId) {
+            const key = normalizePath(fileName);
+            const value = sourceFiles.get(key);
+            if (value) {
+                if (value.languageId !== languageId) {
+                    // languageId changed
+                    this.deleteSource(fileName);
+                    return this.updateSource(fileName, snapshot, languageId);
+                }
+                else {
+                    value.snapshot = snapshot;
+                    deleteVirtualFiles(value);
+                    value.language.updateVirtualFile(value.root, snapshot);
+                    updateVirtualFiles(value);
+                    return value.root; // updated
+                }
+            }
+            for (const language of languages) {
+                const virtualFile = language.createVirtualFile(fileName, snapshot, languageId);
+                if (virtualFile) {
+                    const source = { fileName, languageId, snapshot, root: virtualFile, language };
+                    sourceFiles.set(key, source);
+                    updateVirtualFiles(source);
+                    return virtualFile; // created
+                }
+            }
+        },
+        deleteSource(fileName) {
+            const key = normalizePath(fileName);
+            const value = sourceFiles.get(key);
+            if (value) {
+                value.language.deleteVirtualFile?.(value.root);
+                sourceFiles.delete(key); // deleted
+                deleteVirtualFiles(value);
+            }
+        },
+        getSource(fileName) {
+            const key = normalizePath(fileName);
+            return sourceFiles.get(key);
+        },
+        hasSource: (fileName) => sourceFiles.has(normalizePath(fileName)),
+        getMirrorMap: getMirrorMap,
+        getMaps: getMapsByVirtualFile,
+        hasVirtualFile(fileName) {
+            return !!virtualFiles.get(normalizePath(fileName));
+        },
+        getVirtualFile(fileName) {
+            const sourceAndVirtual = virtualFiles.get(normalizePath(fileName));
+            if (sourceAndVirtual) {
+                return [sourceAndVirtual.virtualFile, sourceAndVirtual.source];
+            }
+            return [undefined, undefined];
+        },
+    };
+    function deleteVirtualFiles(source) {
+        forEachEmbeddedFile(source.root, file => {
+            virtualFiles.delete(normalizePath(file.fileName));
+        });
+    }
+    function updateVirtualFiles(source) {
+        forEachEmbeddedFile(source.root, file => {
+            virtualFiles.set(normalizePath(file.fileName), { virtualFile: file, source });
+        });
+    }
+    function getMapsByVirtualFile(virtualFile) {
+        if (!virtualFileMaps.has(virtualFile.snapshot)) {
+            virtualFileMaps.set(virtualFile.snapshot, new Map());
+        }
+        updateVirtualFileMaps(virtualFile, sourceFileName => {
+            if (sourceFileName) {
+                const source = sourceFiles.get(normalizePath(sourceFileName));
+                return [sourceFileName, source.snapshot];
+            }
+            else {
+                const source = virtualFiles.get(normalizePath(virtualFile.fileName)).source;
+                return [source.fileName, source.snapshot];
+            }
+        }, virtualFileMaps.get(virtualFile.snapshot));
+        return virtualFileMaps.get(virtualFile.snapshot);
+    }
+    function getMirrorMap(file) {
+        if (!virtualFileToMirrorMap.has(file.snapshot)) {
+            virtualFileToMirrorMap.set(file.snapshot, file.mirrorBehaviorMappings ? new sourceMaps_1.MirrorMap(file.mirrorBehaviorMappings) : undefined);
+        }
+        return virtualFileToMirrorMap.get(file.snapshot);
+    }
+}
+exports.createVirtualFiles = createVirtualFiles;
+function updateVirtualFileMaps(virtualFile, getSourceSnapshot, map = new Map()) {
+    const sources = new Set();
+    for (const mapping of virtualFile.mappings) {
+        if (sources.has(mapping.source))
+            continue;
+        sources.add(mapping.source);
+        const source = getSourceSnapshot(mapping.source);
+        if (!source)
+            continue;
+        if (!map.has(source[0]) || map.get(source[0])[0] !== source[1]) {
+            map.set(source[0], [source[1], new source_map_1.SourceMap(virtualFile.mappings.filter(mapping2 => mapping2.source === mapping.source))]);
+        }
+    }
+    return map;
+}
+exports.updateVirtualFileMaps = updateVirtualFileMaps;
+function forEachEmbeddedFile(file, cb) {
+    cb(file);
+    for (const embeddedFile of file.embeddedFiles) {
+        forEachEmbeddedFile(embeddedFile, cb);
+    }
+}
+exports.forEachEmbeddedFile = forEachEmbeddedFile;
+function normalizePath(fileName) {
+    return fileName.replace(/\\/g, '/').toLowerCase();
+}
+//# sourceMappingURL=virtualFiles.js.map

node_modules/@volar/language-core/package.json

@@ -0,0 +1,18 @@
+{
+	"name": "@volar/language-core",
+	"version": "1.11.1",
+	"license": "MIT",
+	"files": [
+		"**/*.js",
+		"**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/volar.js.git",
+		"directory": "packages/language-core"
+	},
+	"dependencies": {
+		"@volar/source-map": "1.11.1"
+	},
+	"gitHead": "188f49ee79bd2ea8e8fc32b80003c85f79868f9d"
+}

node_modules/@volar/source-map/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.

node_modules/@volar/source-map/index.d.ts

@@ -0,0 +1,28 @@
+import { Segment, StackNode } from 'muggle-string';
+export * from 'muggle-string';
+export interface Mapping<T = any> {
+    source?: string;
+    sourceRange: [number, number];
+    generatedRange: [number, number];
+    data: T;
+}
+export interface Stack {
+    source: string;
+    range: [number, number];
+}
+export declare class SourceMap<Data = any> {
+    readonly mappings: Mapping<Data>[];
+    private _memo;
+    private get memo();
+    constructor(mappings: Mapping<Data>[]);
+    toSourceOffset(start: number, baseOnRight?: boolean): readonly [number, Mapping<Data>] | undefined;
+    toGeneratedOffset(start: number, baseOnRight?: boolean): readonly [number, Mapping<Data>] | undefined;
+    toSourceOffsets(start: number, baseOnRight?: boolean): Generator<readonly [number, Mapping<Data>], void, unknown>;
+    toGeneratedOffsets(start: number, baseOnRight?: boolean): Generator<readonly [number, Mapping<Data>], void, unknown>;
+    matching(startOffset: number, from: 'sourceRange' | 'generatedRange', to: 'sourceRange' | 'generatedRange', baseOnRight: boolean): Generator<readonly [number, Mapping<Data>], void, unknown>;
+    matchOffset(start: number, mappedFromRange: [number, number], mappedToRange: [number, number], baseOnRight: boolean): number | undefined;
+    private binarySearchMemo;
+}
+export declare function buildMappings<T>(chunks: Segment<T>[]): Mapping<T>[];
+export declare function buildStacks<T>(chunks: Segment<T>[], stacks: StackNode[]): Stack[];
+//# sourceMappingURL=index.d.ts.map

node_modules/@volar/source-map/index.js

@@ -0,0 +1,182 @@
+"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.buildStacks = exports.buildMappings = exports.SourceMap = void 0;
+__exportStar(require("muggle-string"), exports);
+class SourceMap {
+    get memo() {
+        if (!this._memo) {
+            const self = this;
+            this._memo = {
+                sourceRange: createMemo('sourceRange'),
+                generatedRange: createMemo('generatedRange'),
+            };
+            function createMemo(key) {
+                const offsets = new Set();
+                for (const mapping of self.mappings) {
+                    offsets.add(mapping[key][0]);
+                    offsets.add(mapping[key][1]);
+                }
+                const arr = [...offsets].sort((a, b) => a - b).map(offset => ({ offset, mappings: new Set() }));
+                for (const mapping of self.mappings) {
+                    const startIndex = binarySearch(mapping[key][0]);
+                    const endIndex = binarySearch(mapping[key][1]);
+                    for (let i = startIndex; i <= endIndex; i++) {
+                        arr[i].mappings.add(mapping);
+                    }
+                }
+                return arr;
+                function binarySearch(start) {
+                    let low = 0;
+                    let high = arr.length - 1;
+                    while (low <= high) {
+                        const mid = Math.floor((low + high) / 2);
+                        const midValue = arr[mid];
+                        if (midValue.offset < start) {
+                            low = mid + 1;
+                        }
+                        else if (midValue.offset > start) {
+                            high = mid - 1;
+                        }
+                        else {
+                            return mid;
+                        }
+                    }
+                }
+            }
+        }
+        return this._memo;
+    }
+    constructor(mappings) {
+        this.mappings = mappings;
+    }
+    toSourceOffset(start, baseOnRight = false) {
+        for (const mapped of this.matching(start, 'generatedRange', 'sourceRange', baseOnRight)) {
+            return mapped;
+        }
+    }
+    toGeneratedOffset(start, baseOnRight = false) {
+        for (const mapped of this.matching(start, 'sourceRange', 'generatedRange', baseOnRight)) {
+            return mapped;
+        }
+    }
+    toSourceOffsets(start, baseOnRight = false) {
+        return this.matching(start, 'generatedRange', 'sourceRange', baseOnRight);
+    }
+    toGeneratedOffsets(start, baseOnRight = false) {
+        return this.matching(start, 'sourceRange', 'generatedRange', baseOnRight);
+    }
+    *matching(startOffset, from, to, baseOnRight) {
+        const memo = this.memo[from];
+        if (memo.length === 0)
+            return;
+        const { low: start, high: end, } = this.binarySearchMemo(memo, startOffset);
+        const skip = new Set();
+        for (let i = start; i <= end; i++) {
+            for (const mapping of memo[i].mappings) {
+                if (skip.has(mapping)) {
+                    continue;
+                }
+                skip.add(mapping);
+                const mapped = this.matchOffset(startOffset, mapping[from], mapping[to], baseOnRight);
+                if (mapped !== undefined) {
+                    yield [mapped, mapping];
+                }
+            }
+        }
+    }
+    matchOffset(start, mappedFromRange, mappedToRange, baseOnRight) {
+        if (start >= mappedFromRange[0] && start <= mappedFromRange[1]) {
+            let offset = mappedToRange[0] + start - mappedFromRange[0];
+            if (baseOnRight) {
+                offset += (mappedToRange[1] - mappedToRange[0]) - (mappedFromRange[1] - mappedFromRange[0]);
+            }
+            if (offset >= mappedToRange[0] && offset <= mappedToRange[1]) {
+                return offset;
+            }
+        }
+    }
+    binarySearchMemo(array, start) {
+        let low = 0;
+        let high = array.length - 1;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const midValue = array[mid];
+            if (midValue.offset < start) {
+                low = mid + 1;
+            }
+            else if (midValue.offset > start) {
+                high = mid - 1;
+            }
+            else {
+                low = mid;
+                high = mid;
+                break;
+            }
+        }
+        return {
+            low: Math.max(Math.min(low, high, array.length - 1), 0),
+            high: Math.min(Math.max(low, high, 0), array.length - 1),
+        };
+    }
+}
+exports.SourceMap = SourceMap;
+function buildMappings(chunks) {
+    let length = 0;
+    const mappings = [];
+    for (const segment of chunks) {
+        if (typeof segment === 'string') {
+            length += segment.length;
+        }
+        else {
+            mappings.push({
+                generatedRange: [length, length + segment[0].length],
+                source: segment[1],
+                sourceRange: typeof segment[2] === 'number' ? [segment[2], segment[2] + segment[0].length] : segment[2],
+                // @ts-ignore
+                data: segment[3],
+            });
+            length += segment[0].length;
+        }
+    }
+    return mappings;
+}
+exports.buildMappings = buildMappings;
+function buildStacks(chunks, stacks) {
+    let offset = 0;
+    let index = 0;
+    const result = [];
+    for (const stack of stacks) {
+        const start = offset;
+        for (let i = 0; i < stack.length; i++) {
+            const segment = chunks[index + i];
+            if (typeof segment === 'string') {
+                offset += segment.length;
+            }
+            else {
+                offset += segment[0].length;
+            }
+        }
+        index += stack.length;
+        result.push({
+            range: [start, offset],
+            source: stack.stack,
+        });
+    }
+    return result;
+}
+exports.buildStacks = buildStacks;
+//# sourceMappingURL=index.js.map

node_modules/@volar/source-map/package.json

@@ -0,0 +1,18 @@
+{
+	"name": "@volar/source-map",
+	"version": "1.11.1",
+	"license": "MIT",
+	"files": [
+		"**/*.js",
+		"**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/volar.js.git",
+		"directory": "packages/source-map"
+	},
+	"dependencies": {
+		"muggle-string": "^0.3.1"
+	},
+	"gitHead": "188f49ee79bd2ea8e8fc32b80003c85f79868f9d"
+}

node_modules/@volar/typescript/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.

node_modules/@volar/typescript/index.d.ts

@@ -0,0 +1,7 @@
+export * from './lib/documentRegistry';
+export * from './lib/languageService';
+export * from './lib/languageServiceHost';
+export * from './lib/sys';
+export * from './lib/getProgram';
+export * from './lib/serverPlugin';
+//# sourceMappingURL=index.d.ts.map

node_modules/@volar/typescript/index.js

@@ -0,0 +1,23 @@
+"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 });
+__exportStar(require("./lib/documentRegistry"), exports);
+__exportStar(require("./lib/languageService"), exports);
+__exportStar(require("./lib/languageServiceHost"), exports);
+__exportStar(require("./lib/sys"), exports);
+__exportStar(require("./lib/getProgram"), exports);
+__exportStar(require("./lib/serverPlugin"), exports);
+//# sourceMappingURL=index.js.map

node_modules/@volar/typescript/lib/documentRegistry.d.ts

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

node_modules/@volar/typescript/lib/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

node_modules/@volar/typescript/lib/getProgram.d.ts

@@ -0,0 +1,4 @@
+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, sys: ts.System): ts.Program;
+//# sourceMappingURL=getProgram.d.ts.map

node_modules/@volar/typescript/lib/getProgram.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProgram = void 0;
+function getProgram(ts, core, ls, sys) {
+    const proxy = {
+        getRootFileNames,
+        emit,
+        getSyntacticDiagnostics,
+        getSemanticDiagnostics,
+        getGlobalDiagnostics,
+        // @ts-expect-error
+        getBindAndCheckDiagnostics,
+    };
+    return new Proxy({}, {
+        get: (target, property) => {
+            if (property in proxy) {
+                return proxy[property];
+            }
+            const program = getProgram();
+            if (property in program) {
+                return program[property];
+            }
+            return target[property];
+        },
+        // #17
+        // notice: https://github.com/vuejs/language-tools/issues/2403
+        set: (target, property, newValue) => {
+            const program = getProgram();
+            target[property] = program[property] = newValue;
+            return true;
+        },
+    });
+    function getProgram() {
+        return ls.getProgram();
+    }
+    function getRootFileNames() {
+        return getProgram().getRootFileNames().filter(fileName => sys.fileExists?.(fileName));
+    }
+    // for vue-tsc --noEmit --watch
+    function getBindAndCheckDiagnostics(sourceFile, cancellationToken) {
+        return getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, 'getBindAndCheckDiagnostics');
+    }
+    // for vue-tsc --noEmit
+    function getSyntacticDiagnostics(sourceFile, cancellationToken) {
+        return getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, 'getSyntacticDiagnostics');
+    }
+    function getSemanticDiagnostics(sourceFile, cancellationToken) {
+        return getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, 'getSemanticDiagnostics');
+    }
+    function getSourceFileDiagnosticsWorker(sourceFile, cancellationToken, api) {
+        if (sourceFile) {
+            const [virtualFile, source] = core.virtualFiles.getVirtualFile(sourceFile.fileName);
+            if (virtualFile && source) {
+                if (!virtualFile.capabilities.diagnostic)
+                    return [];
+                const errors = transformDiagnostics(ls.getProgram()?.[api](sourceFile, cancellationToken) ?? []);
+                return errors;
+            }
+        }
+        return transformDiagnostics(getProgram()[api](sourceFile, cancellationToken) ?? []);
+    }
+    function getGlobalDiagnostics(cancellationToken) {
+        return transformDiagnostics(getProgram().getGlobalDiagnostics(cancellationToken) ?? []);
+    }
+    function emit(targetSourceFile, _writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
+        const scriptResult = getProgram().emit(targetSourceFile, (sys.writeFile ?? ts.sys.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers);
+        return {
+            emitSkipped: scriptResult.emitSkipped,
+            emittedFiles: scriptResult.emittedFiles,
+            diagnostics: transformDiagnostics(scriptResult.diagnostics),
+        };
+    }
+    // transform
+    function transformDiagnostics(diagnostics) {
+        const result = [];
+        for (const diagnostic of diagnostics) {
+            if (diagnostic.file !== undefined
+                && diagnostic.start !== undefined
+                && diagnostic.length !== undefined) {
+                const [virtualFile, source] = core.virtualFiles.getVirtualFile(diagnostic.file.fileName);
+                if (virtualFile && source) {
+                    if (sys.fileExists?.(source.fileName) === false)
+                        continue;
+                    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' ? start[1].data.diagnostic.shouldReport() : !!start[1].data.diagnostic;
+                            if (!reportStart)
+                                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)
+                                    continue;
+                                onMapping(diagnostic, source.fileName, start[0], end[0], source.snapshot.getText(0, source.snapshot.getLength()));
+                                break;
+                            }
+                            break;
+                        }
+                    }
+                }
+                else {
+                    if (sys.fileExists?.(diagnostic.file.fileName) === false)
+                        continue;
+                    onMapping(diagnostic, diagnostic.file.fileName, diagnostic.start, diagnostic.start + diagnostic.length, diagnostic.file.text);
+                }
+            }
+            else if (diagnostic.file === undefined) {
+                result.push(diagnostic);
+            }
+        }
+        return result;
+        function onMapping(diagnostic, fileName, start, end, docText) {
+            let file = fileName === diagnostic.file?.fileName
+                ? diagnostic.file
+                : undefined;
+            if (!file) {
+                if (docText === undefined) {
+                    const snapshot = core.host.getScriptSnapshot(fileName);
+                    if (snapshot) {
+                        docText = snapshot.getText(0, snapshot.getLength());
+                    }
+                }
+                else {
+                    file = ts.createSourceFile(fileName, docText, ts.ScriptTarget.Latest, undefined, ts.ScriptKind.Deferred);
+                    // fix https://github.com/vuejs/language-tools/issues/2622 for TS 5.0
+                    file.originalFileName = fileName;
+                    file.path = fileName.toLowerCase();
+                    file.resolvedPath = fileName.toLowerCase();
+                }
+            }
+            const newDiagnostic = {
+                ...diagnostic,
+                file,
+                start: start,
+                length: end - start,
+            };
+            const relatedInformation = diagnostic.relatedInformation;
+            if (relatedInformation) {
+                newDiagnostic.relatedInformation = transformDiagnostics(relatedInformation);
+            }
+            result.push(newDiagnostic);
+        }
+    }
+}
+exports.getProgram = getProgram;
+//# sourceMappingURL=getProgram.js.map

node_modules/@volar/typescript/lib/languageService.d.ts

@@ -0,0 +1,4 @@
+import { VirtualFiles } from '@volar/language-core';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function decorateLanguageService(virtualFiles: VirtualFiles, languageService: ts.LanguageService, isTsPlugin: boolean): void;
+//# sourceMappingURL=languageService.d.ts.map

node_modules/@volar/typescript/lib/languageService.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateLanguageService = void 0;
+const language_core_1 = require("@volar/language-core");
+function decorateLanguageService(virtualFiles, languageService, isTsPlugin) {
+    const _organizeImports = languageService.organizeImports.bind(languageService);
+    const _getDefinitionAtPosition = languageService.getDefinitionAtPosition.bind(languageService);
+    const _getDefinitionAndBoundSpan = languageService.getDefinitionAndBoundSpan.bind(languageService);
+    const _getTypeDefinitionAtPosition = languageService.getTypeDefinitionAtPosition.bind(languageService);
+    const _getImplementationAtPosition = languageService.getImplementationAtPosition.bind(languageService);
+    const _getFileReferences = languageService.getFileReferences.bind(languageService);
+    const _findRenameLocations = languageService.findRenameLocations.bind(languageService);
+    const _getReferencesAtPosition = languageService.getReferencesAtPosition.bind(languageService);
+    const _findReferences = languageService.findReferences.bind(languageService);
+    languageService.organizeImports = organizeImports;
+    languageService.getDefinitionAtPosition = getDefinitionAtPosition;
+    languageService.getDefinitionAndBoundSpan = getDefinitionAndBoundSpan;
+    languageService.getTypeDefinitionAtPosition = getTypeDefinitionAtPosition;
+    languageService.getImplementationAtPosition = getImplementationAtPosition;
+    languageService.findRenameLocations = findRenameLocations;
+    languageService.getReferencesAtPosition = getReferencesAtPosition;
+    languageService.getFileReferences = getFileReferences;
+    languageService.findReferences = findReferences;
+    // apis
+    function organizeImports(args, formatOptions, preferences) {
+        let edits = [];
+        const file = virtualFiles.getSource(args.fileName)?.root;
+        if (file) {
+            (0, language_core_1.forEachEmbeddedFile)(file, embeddedFile => {
+                if (embeddedFile.kind === language_core_1.FileKind.TypeScriptHostFile && embeddedFile.capabilities.codeAction) {
+                    edits = edits.concat(_organizeImports({
+                        ...args,
+                        fileName: embeddedFile.fileName,
+                    }, formatOptions, preferences));
+                }
+            });
+        }
+        else {
+            return _organizeImports(args, formatOptions, preferences);
+        }
+        return edits.map(transformFileTextChanges).filter(notEmpty);
+    }
+    function getReferencesAtPosition(fileName, position) {
+        return findLocations(fileName, position, 'references');
+    }
+    function getFileReferences(fileName) {
+        return findLocations(fileName, -1, 'fileReferences');
+    }
+    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, preferences) {
+        return findLocations(fileName, position, 'rename', findInStrings, findInComments, preferences);
+    }
+    function findLocations(fileName, position, mode, findInStrings = false, findInComments = false, preferences) {
+        const loopChecker = new Set();
+        let symbols = [];
+        withMirrors(fileName, position);
+        return symbols.map(s => transformDocumentSpanLike(s, mode === 'definition')).filter(notEmpty);
+        function withMirrors(fileName, position) {
+            if (loopChecker.has(fileName + ':' + position))
+                return;
+            loopChecker.add(fileName + ':' + position);
+            const _symbols = mode === 'definition' ? _getDefinitionAtPosition(fileName, position)
+                : mode === 'typeDefinition' ? _getTypeDefinitionAtPosition(fileName, position)
+                    : mode === 'references' ? _getReferencesAtPosition(fileName, position)
+                        : mode === 'fileReferences' ? _getFileReferences(fileName)
+                            : mode === 'implementation' ? _getImplementationAtPosition(fileName, position)
+                                : mode === 'rename' && preferences ? _findRenameLocations(fileName, position, findInStrings, findInComments, preferences)
+                                    : undefined;
+            if (!_symbols)
+                return;
+            symbols = symbols.concat(_symbols);
+            for (const ref of _symbols) {
+                loopChecker.add(ref.fileName + ':' + ref.textSpan.start);
+                const [virtualFile] = getVirtualFile(ref.fileName);
+                if (!virtualFile)
+                    continue;
+                const mirrorMap = 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, true)).filter(notEmpty),
+        };
+        function withMirrors(fileName, position) {
+            if (loopChecker.has(fileName + ':' + position))
+                return;
+            loopChecker.add(fileName + ':' + position);
+            const _symbols = _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] = getVirtualFile(ref.fileName);
+                if (!virtualFile)
+                    continue;
+                const mirrorMap = 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 = _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] = getVirtualFile(ref.fileName);
+                    if (!virtualFile)
+                        continue;
+                    const mirrorMap = 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] = 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, false);
+        const references = symbol.references.map(r => transformDocumentSpanLike(r, false)).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, isDefinition) {
+        let textSpan = transformSpan(documentSpan.fileName, documentSpan.textSpan);
+        if (isDefinition && !textSpan) {
+            const [virtualFile, source] = getVirtualFile(documentSpan.fileName);
+            if (virtualFile && source) {
+                textSpan = {
+                    fileName: source.fileName,
+                    textSpan: { start: 0, length: 0 },
+                };
+            }
+        }
+        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] = getVirtualFile(fileName);
+        if (virtualFile && source) {
+            if (isTsPlugin) {
+                textSpan = {
+                    start: textSpan.start - source.snapshot.getLength(),
+                    length: textSpan.length,
+                };
+            }
+            for (const [_, [sourceSnapshot, map]] of virtualFiles.getMaps(virtualFile)) {
+                if (source.snapshot !== sourceSnapshot)
+                    continue;
+                const sourceLoc = map.toSourceOffset(textSpan.start);
+                if (sourceLoc) {
+                    return {
+                        fileName: source.fileName,
+                        textSpan: {
+                            start: sourceLoc[0],
+                            length: textSpan.length,
+                        },
+                    };
+                }
+            }
+        }
+        else {
+            return {
+                fileName,
+                textSpan,
+            };
+        }
+    }
+    function getVirtualFile(fileName) {
+        if (isTsPlugin) {
+            let result;
+            const source = virtualFiles.getSource(fileName);
+            if (source) {
+                (0, language_core_1.forEachEmbeddedFile)(source.root, file => {
+                    const ext = file.fileName.replace(fileName, '');
+                    if (file.kind === language_core_1.FileKind.TypeScriptHostFile && (ext === '.d.ts' || ext.match(/^\.(js|ts)x?$/))) {
+                        result = file;
+                    }
+                });
+            }
+            return [result, source];
+        }
+        else {
+            return virtualFiles.getVirtualFile(fileName);
+        }
+    }
+}
+exports.decorateLanguageService = decorateLanguageService;
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=languageService.js.map

node_modules/@volar/typescript/lib/languageServiceHost.d.ts

@@ -0,0 +1,6 @@
+import type { LanguageContext } from '@volar/language-core';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+export declare function createLanguageServiceHost(ctx: LanguageContext, ts: typeof import('typescript/lib/tsserverlibrary'), sys: ts.System & {
+    version?: number;
+}): ts.LanguageServiceHost;
+//# sourceMappingURL=languageServiceHost.d.ts.map

node_modules/@volar/typescript/lib/languageServiceHost.js

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLanguageServiceHost = void 0;
+const path = require("path-browserify");
+const utilities_1 = require("./typescript/utilities");
+const fileVersions = new Map();
+function createLanguageServiceHost(ctx, ts, sys) {
+    let lastProjectVersion;
+    let tsProjectVersion = 0;
+    let tsFileNames = [];
+    let tsDirectories = new Set();
+    const _tsHost = {
+        ...sys,
+        getCurrentDirectory: () => ctx.host.workspacePath,
+        getCompilationSettings: () => ctx.host.getCompilationSettings(),
+        getCancellationToken: ctx.host.getCancellationToken ? () => ctx.host.getCancellationToken() : undefined,
+        getLocalizedDiagnosticMessages: ctx.host.getLocalizedDiagnosticMessages ? () => ctx.host.getLocalizedDiagnosticMessages() : undefined,
+        getProjectReferences: ctx.host.getProjectReferences ? () => ctx.host.getProjectReferences() : undefined,
+        getDefaultLibFileName: (options) => {
+            try {
+                return ts.getDefaultLibFilePath(options);
+            }
+            catch {
+                // web
+                return `/node_modules/typescript/lib/${ts.getDefaultLibFileName(options)}`;
+            }
+        },
+        useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames,
+        getNewLine: () => sys.newLine,
+        readFile: fileName => {
+            const snapshot = getScriptSnapshot(fileName);
+            if (snapshot) {
+                return snapshot.getText(0, snapshot.getLength());
+            }
+        },
+        readDirectory,
+        getDirectories,
+        directoryExists,
+        fileExists,
+        getProjectVersion: () => {
+            return tsProjectVersion + ':' + sys.version;
+        },
+        getTypeRootsVersion: () => {
+            return sys.version ?? -1; // TODO: only update for /node_modules changes?
+        },
+        getScriptFileNames: () => tsFileNames,
+        getScriptVersion,
+        getScriptSnapshot,
+        getScriptKind(fileName) {
+            if (ts) {
+                if (ctx.virtualFiles.hasSource(fileName))
+                    return ts.ScriptKind.Deferred;
+                switch (path.extname(fileName)) {
+                    case '.js': return ts.ScriptKind.JS;
+                    case '.cjs': return ts.ScriptKind.JS;
+                    case '.mjs': return ts.ScriptKind.JS;
+                    case '.jsx': return ts.ScriptKind.JSX;
+                    case '.ts': return ts.ScriptKind.TS;
+                    case '.cts': return ts.ScriptKind.TS;
+                    case '.mts': return ts.ScriptKind.TS;
+                    case '.tsx': return ts.ScriptKind.TSX;
+                    case '.json': return ts.ScriptKind.JSON;
+                    default: return ts.ScriptKind.Unknown;
+                }
+            }
+            return 0;
+        },
+    };
+    const fsFileSnapshots = new Map();
+    if (ctx.host.resolveModuleName) {
+        // TODO: can this share between monorepo packages?
+        const moduleCache = ts.createModuleResolutionCache(_tsHost.getCurrentDirectory(), _tsHost.useCaseSensitiveFileNames ? s => s : s => s.toLowerCase(), _tsHost.getCompilationSettings());
+        let lastSysVersion = sys.version;
+        _tsHost.resolveModuleNameLiterals = (moduleLiterals, containingFile, redirectedReference, options, sourceFile) => {
+            if (lastSysVersion !== sys.version) {
+                lastSysVersion = sys.version;
+                moduleCache.clear();
+            }
+            return moduleLiterals.map((moduleLiteral) => {
+                let moduleName = moduleLiteral.text;
+                moduleName = ctx.host.resolveModuleName(moduleName, sourceFile.impliedNodeFormat);
+                return ts.resolveModuleName(moduleName, containingFile, options, _tsHost, moduleCache, redirectedReference, sourceFile.impliedNodeFormat);
+            });
+        };
+        _tsHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, options, sourceFile) => {
+            if (lastSysVersion !== sys.version) {
+                lastSysVersion = sys.version;
+                moduleCache.clear();
+            }
+            return moduleNames.map((moduleName) => {
+                moduleName = ctx.host.resolveModuleName(moduleName, sourceFile?.impliedNodeFormat);
+                return ts.resolveModuleName(moduleName, containingFile, options, _tsHost, moduleCache, redirectedReference, sourceFile?.impliedNodeFormat).resolvedModule;
+            });
+        };
+    }
+    let oldTsVirtualFileSnapshots = new Set();
+    let oldOtherVirtualFileSnapshots = new Set();
+    return new Proxy(_tsHost, {
+        get: (target, property) => {
+            sync();
+            return target[property];
+        },
+    });
+    function sync() {
+        const newProjectVersion = ctx.host.getProjectVersion();
+        const shouldUpdate = newProjectVersion !== lastProjectVersion;
+        if (!shouldUpdate)
+            return;
+        lastProjectVersion = newProjectVersion;
+        const newTsVirtualFileSnapshots = new Set();
+        const newOtherVirtualFileSnapshots = new Set();
+        for (const { root } of ctx.virtualFiles.allSources()) {
+            forEachEmbeddedFile(root, embedded => {
+                if (embedded.kind === 1) {
+                    newTsVirtualFileSnapshots.add(embedded.snapshot);
+                }
+                else {
+                    newOtherVirtualFileSnapshots.add(embedded.snapshot);
+                }
+            });
+        }
+        if (!setEquals(oldTsVirtualFileSnapshots, newTsVirtualFileSnapshots)) {
+            tsProjectVersion++;
+        }
+        else if (setEquals(oldOtherVirtualFileSnapshots, newOtherVirtualFileSnapshots)) {
+            // no any meta language files update, it mean project version was update by source files this time
+            tsProjectVersion++;
+        }
+        oldTsVirtualFileSnapshots = newTsVirtualFileSnapshots;
+        oldOtherVirtualFileSnapshots = newOtherVirtualFileSnapshots;
+        const tsFileNamesSet = new Set();
+        for (const { root } of ctx.virtualFiles.allSources()) {
+            forEachEmbeddedFile(root, embedded => {
+                if (embedded.kind === 1) {
+                    tsFileNamesSet.add(embedded.fileName); // virtual .ts
+                }
+            });
+        }
+        for (const fileName of ctx.host.getScriptFileNames()) {
+            if (!ctx.virtualFiles.hasSource(fileName)) {
+                tsFileNamesSet.add(fileName); // .ts
+            }
+        }
+        tsFileNames = [...tsFileNamesSet];
+        // Update tsDirectories for `directoryExists()`
+        tsDirectories.clear();
+        for (const fileName of tsFileNames) {
+            tsDirectories.add(path.dirname(normalizePath(fileName)));
+        }
+    }
+    function readDirectory(dirName, extensions, excludes, includes, depth) {
+        let matches = (0, utilities_1.matchFiles)(dirName, extensions, excludes, includes, sys?.useCaseSensitiveFileNames ?? false, ctx.host.workspacePath, depth, (dirPath) => {
+            const files = [];
+            for (const fileName of tsFileNames) {
+                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] = ctx.virtualFiles.getVirtualFile(match);
+            if (source) {
+                return source.fileName;
+            }
+            return match;
+        });
+        return [...new Set([
+                ...matches,
+                ...sys.readDirectory(dirName, extensions, excludes, includes, depth),
+            ])];
+    }
+    function getDirectories(dirName) {
+        return [...new Set([
+                ...getVirtualFileDirectories(dirName),
+                ...sys.getDirectories(dirName),
+            ])];
+    }
+    function getVirtualFileDirectories(dirName) {
+        const names = new Set();
+        for (const fileName of tsFileNames) {
+            if (fileName.toLowerCase().startsWith(dirName.toLowerCase())) {
+                const path = fileName.substring(dirName.length);
+                if (path.indexOf('/') >= 0) {
+                    names.add(path.split('/')[0]);
+                }
+            }
+        }
+        return [...names];
+    }
+    function getScriptSnapshot(fileName) {
+        // virtual files
+        const [virtualFile] = ctx.virtualFiles.getVirtualFile(fileName);
+        if (virtualFile) {
+            return virtualFile.snapshot;
+        }
+        // root files / opened files
+        const tsScript = ctx.host.getScriptSnapshot(fileName);
+        if (tsScript) {
+            return tsScript;
+        }
+        // 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]);
+            }
+        }
+        return fsFileSnapshots.get(fileName)?.[1];
+    }
+    function getScriptVersion(fileName) {
+        // virtual files / root files / opened files
+        const [virtualFile] = ctx.virtualFiles.getVirtualFile(fileName);
+        const snapshot = virtualFile?.snapshot ?? ctx.host.getScriptSnapshot(fileName);
+        if (snapshot) {
+            if (!fileVersions.has(fileName)) {
+                fileVersions.set(fileName, { lastVersion: 0, snapshotVersions: new WeakMap() });
+            }
+            const version = fileVersions.get(fileName);
+            if (!version.snapshotVersions.has(snapshot)) {
+                version.snapshotVersions.set(snapshot, version.lastVersion++);
+            }
+            return version.snapshotVersions.get(snapshot).toString();
+        }
+        // fs files
+        return sys.getModifiedTime?.(fileName)?.valueOf().toString() ?? '';
+    }
+    function directoryExists(dirName) {
+        return tsDirectories.has(normalizePath(dirName)) || sys.directoryExists(dirName);
+    }
+    function fileExists(fileName) {
+        // fill external virtual files
+        const ext = fileName.substring(fileName.lastIndexOf('.'));
+        if (ext === '.js'
+            || ext === '.ts'
+            || ext === '.jsx'
+            || ext === '.tsx') {
+            /**
+             * If try to access a external .vue file that outside of the project,
+             * the file will not process by language service host,
+             * so virtual file will not be created.
+             *
+             * We try to create virtual file here.
+             */
+            const sourceFileName = fileName.substring(0, fileName.lastIndexOf('.'));
+            if (!ctx.virtualFiles.hasSource(sourceFileName)) {
+                const scriptSnapshot = getScriptSnapshot(sourceFileName);
+                if (scriptSnapshot) {
+                    ctx.virtualFiles.updateSource(sourceFileName, scriptSnapshot, ctx.host.getLanguageId?.(sourceFileName));
+                }
+            }
+        }
+        // virtual files
+        if (ctx.virtualFiles.hasVirtualFile(fileName)) {
+            return true;
+        }
+        // root files
+        if (ctx.host.getScriptSnapshot(fileName)) {
+            return true;
+        }
+        // fs files
+        return !!sys.fileExists(fileName);
+    }
+}
+exports.createLanguageServiceHost = createLanguageServiceHost;
+function setEquals(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const item of a) {
+        if (!b.has(item))
+            return false;
+    }
+    return true;
+}
+function forEachEmbeddedFile(file, cb) {
+    cb(file);
+    for (const embeddedFile of file.embeddedFiles) {
+        forEachEmbeddedFile(embeddedFile, cb);
+    }
+}
+function normalizePath(fileName) {
+    return fileName.replace(/\\/g, '/').toLowerCase();
+}
+//# sourceMappingURL=languageServiceHost.js.map

node_modules/@volar/typescript/lib/serverPlugin.d.ts

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

node_modules/@volar/typescript/lib/serverPlugin.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExternalFiles = exports.searchExternalFiles = exports.decorateLanguageServiceHost = void 0;
+const language_core_1 = require("@volar/language-core");
+function decorateLanguageServiceHost(virtualFiles, languageServiceHost, ts, exts) {
+    let extraProjectVersion = 0;
+    const scripts = new Map();
+    const readDirectory = languageServiceHost.readDirectory?.bind(languageServiceHost);
+    const resolveModuleNameLiterals = languageServiceHost.resolveModuleNameLiterals?.bind(languageServiceHost);
+    const resolveModuleNames = languageServiceHost.resolveModuleNames?.bind(languageServiceHost);
+    const getProjectVersion = languageServiceHost.getProjectVersion?.bind(languageServiceHost);
+    const getScriptSnapshot = languageServiceHost.getScriptSnapshot.bind(languageServiceHost);
+    const getScriptKind = languageServiceHost.getScriptKind?.bind(languageServiceHost);
+    // path completion
+    if (readDirectory) {
+        languageServiceHost.readDirectory = (path, extensions, exclude, include, depth) => {
+            if (extensions) {
+                for (const ext of exts) {
+                    if (!extensions.includes(ext)) {
+                        extensions = [...extensions, ...ext];
+                    }
+                }
+            }
+            return readDirectory(path, extensions, exclude, include, depth);
+        };
+    }
+    if (resolveModuleNameLiterals) {
+        languageServiceHost.resolveModuleNameLiterals = (moduleNames, containingFile, redirectedReference, options, ...rest) => {
+            const resolvedModules = resolveModuleNameLiterals(moduleNames, containingFile, redirectedReference, options, ...rest);
+            return moduleNames.map((name, i) => {
+                if (exts.some(ext => name.text.endsWith(ext))) {
+                    const resolved = resolveModuleName(name.text, containingFile, options, redirectedReference);
+                    if (resolved.resolvedModule) {
+                        return resolved;
+                    }
+                }
+                return resolvedModules[i];
+            });
+        };
+    }
+    else if (resolveModuleNames) {
+        languageServiceHost.resolveModuleNames = (moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile) => {
+            const resolvedModules = resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, options, containingSourceFile);
+            return moduleNames.map((name, i) => {
+                if (exts.some(ext => name.endsWith(ext))) {
+                    const resolved = resolveModuleName(name, containingFile, options, redirectedReference);
+                    if (resolved.resolvedModule) {
+                        return resolved.resolvedModule;
+                    }
+                }
+                return resolvedModules[i];
+            });
+        };
+    }
+    if (getProjectVersion) {
+        languageServiceHost.getProjectVersion = () => {
+            return getProjectVersion() + ':' + extraProjectVersion;
+        };
+    }
+    languageServiceHost.getScriptSnapshot = (fileName) => {
+        if (exts.some(ext => fileName.endsWith(ext))) {
+            updateScript(fileName);
+            return scripts.get(fileName)?.snapshot;
+        }
+        return getScriptSnapshot(fileName);
+    };
+    if (getScriptKind) {
+        languageServiceHost.getScriptKind = (fileName) => {
+            if (exts.some(ext => fileName.endsWith(ext))) {
+                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 ts.ScriptKind.Deferred;
+            }
+            return getScriptKind(fileName);
+        };
+    }
+    function resolveModuleName(name, containingFile, options, redirectedReference) {
+        const resolved = ts.resolveModuleName(name, containingFile, options, {
+            readFile(fileName) {
+                return languageServiceHost.readFile(fileName);
+            },
+            fileExists(fileName) {
+                if (exts.some(ext => fileName.endsWith(ext + '.d.ts'))) {
+                    return fileExists(fileName.slice(0, -'.d.ts'.length));
+                }
+                return languageServiceHost.fileExists(fileName);
+            },
+        }, undefined, redirectedReference);
+        if (resolved.resolvedModule) {
+            resolved.resolvedModule.resolvedFileName = resolved.resolvedModule.resolvedFileName.slice(0, -'.d.ts'.length);
+            const script = updateScript(resolved.resolvedModule.resolvedFileName);
+            if (script) {
+                resolved.resolvedModule.extension = script.extension;
+            }
+        }
+        return resolved;
+    }
+    // fix https://github.com/vuejs/language-tools/issues/3332
+    function fileExists(fileName) {
+        if (languageServiceHost.fileExists(fileName)) {
+            const fileSize = ts.sys.getFileSize?.(fileName) ?? languageServiceHost.readFile(fileName)?.length ?? 0;
+            return fileSize < 4 * 1024 * 1024;
+        }
+        return false;
+    }
+    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) {
+                extraProjectVersion++;
+                const virtualFile = virtualFiles.updateSource(fileName, ts.ScriptSnapshot.fromString(text), undefined);
+                if (virtualFile) {
+                    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?$/))) {
+                            extension = ext;
+                            patchedText += file.snapshot.getText(0, file.snapshot.getLength());
+                        }
+                    });
+                    snapshot = ts.ScriptSnapshot.fromString(patchedText);
+                }
+            }
+            else if (virtualFiles.hasSource(fileName)) {
+                extraProjectVersion++;
+                virtualFiles.deleteSource(fileName);
+            }
+            scripts.set(fileName, {
+                version,
+                snapshot,
+                extension,
+            });
+        }
+        return scripts.get(fileName);
+    }
+}
+exports.decorateLanguageServiceHost = decorateLanguageServiceHost;
+function searchExternalFiles(ts, project, exts) {
+    if (project.projectKind !== ts.server.ProjectKind.Configured) {
+        return [];
+    }
+    const configFile = project.getProjectName();
+    const config = ts.readJsonConfigFile(configFile, project.readFile.bind(project));
+    const parseHost = {
+        useCaseSensitiveFileNames: project.useCaseSensitiveFileNames(),
+        fileExists: project.fileExists.bind(project),
+        readFile: project.readFile.bind(project),
+        readDirectory: (...args) => {
+            args[1] = exts;
+            return project.readDirectory(...args);
+        },
+    };
+    const parsed = ts.parseJsonSourceFileConfigFileContent(config, parseHost, project.getCurrentDirectory());
+    return parsed.fileNames;
+}
+exports.searchExternalFiles = searchExternalFiles;
+/**
+ * @deprecated use `searchExternalFiles` instead
+ */
+exports.getExternalFiles = searchExternalFiles;
+//# sourceMappingURL=serverPlugin.js.map

node_modules/@volar/typescript/lib/sys.d.ts

@@ -0,0 +1,7 @@
+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 & {
+    version: number;
+    sync(): Promise<number>;
+} & Disposable;
+//# sourceMappingURL=sys.d.ts.map

node_modules/@volar/typescript/lib/sys.js

@@ -0,0 +1,341 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSys = void 0;
+const path = require("path-browserify");
+const utilities_1 = require("./typescript/utilities");
+let currentCwd = '';
+function createSys(ts, env) {
+    let version = 0;
+    const rootPath = env.uriToFileName(env.workspaceUri.toString());
+    const sys = ts.sys;
+    const root = {
+        dirs: new Map(),
+        files: new Map(),
+        requestedRead: false,
+    };
+    const promises = new Set();
+    const fileWatcher = env.onDidChangeWatchedFiles?.(({ changes }) => {
+        for (const change of changes) {
+            const fileName = env.uriToFileName(change.uri);
+            const dirName = path.dirname(fileName);
+            const baseName = path.basename(fileName);
+            const dir = getDir(dirName);
+            if (dir.files.has(baseName)) { // is requested file
+                version++;
+                if (change.type === 1 || change.type === 2) {
+                    dir.files.set(baseName, {
+                        stat: {
+                            type: 1,
+                            ctime: Date.now(),
+                            mtime: Date.now(),
+                            size: -1,
+                        },
+                        requestedStat: false,
+                    });
+                }
+                else if (change.type === 3) {
+                    dir.files.set(baseName, {
+                        stat: undefined,
+                        text: undefined,
+                        requestedStat: true,
+                        requestedText: true,
+                    });
+                }
+            }
+        }
+    });
+    return {
+        get version() {
+            return version;
+        },
+        dispose() {
+            fileWatcher?.dispose();
+        },
+        args: sys?.args ?? [],
+        newLine: sys?.newLine ?? '\n',
+        useCaseSensitiveFileNames: sys?.useCaseSensitiveFileNames ?? false,
+        realpath: sys?.realpath,
+        write: sys?.write ?? (() => { }),
+        writeFile: sys?.writeFile ?? (() => { }),
+        createDirectory: sys?.createDirectory ?? (() => { }),
+        exit: sys?.exit ?? (() => { }),
+        getExecutingFilePath: sys?.getExecutingFilePath ?? (() => rootPath + '/__fake__.js'),
+        getCurrentDirectory: () => rootPath,
+        getModifiedTime,
+        readFile,
+        readDirectory,
+        getDirectories,
+        resolvePath,
+        fileExists,
+        directoryExists,
+        async sync() {
+            while (promises.size) {
+                await Promise.all(promises);
+            }
+            return version;
+        },
+    };
+    function resolvePath(fsPath) {
+        if (sys) {
+            if (currentCwd !== rootPath) {
+                currentCwd = rootPath;
+                // https://github.com/vuejs/language-tools/issues/2039
+                // https://github.com/vuejs/language-tools/issues/2234
+                if (sys.directoryExists(rootPath)) {
+                    // https://github.com/vuejs/language-tools/issues/2480
+                    try {
+                        // @ts-expect-error
+                        process.chdir(rootPath);
+                    }
+                    catch { }
+                }
+            }
+            return sys.resolvePath(fsPath).replace(/\\/g, '/');
+        }
+        return path.resolve(fsPath).replace(/\\/g, '/');
+    }
+    function readFile(fileName, encoding) {
+        fileName = resolvePath(fileName);
+        const dirPath = path.dirname(fileName);
+        const dir = getDir(dirPath);
+        const name = path.basename(fileName);
+        readFileWorker(fileName, encoding, dir);
+        return dir.files.get(name)?.text;
+    }
+    function directoryExists(dirName) {
+        dirName = resolvePath(dirName);
+        const dir = getDir(dirName);
+        if (dir.exists === undefined) {
+            dir.exists = false;
+            const result = env.fs?.stat(env.fileNameToUri(dirName));
+            if (typeof result === 'object' && 'then' in result) {
+                const promise = result;
+                promises.add(promise);
+                result.then(result => {
+                    promises.delete(promise);
+                    dir.exists = result?.type === 2;
+                    if (dir.exists) {
+                        version++;
+                    }
+                });
+            }
+            else {
+                dir.exists = result?.type === 2;
+            }
+        }
+        return dir.exists;
+    }
+    function getModifiedTime(fileName) {
+        fileName = resolvePath(fileName);
+        const file = getFile(fileName);
+        if (!file.requestedStat) {
+            file.requestedStat = true;
+            handleStat(fileName, file);
+        }
+        return file.stat ? new Date(file.stat.mtime) : new Date(0);
+    }
+    function fileExists(fileName) {
+        fileName = resolvePath(fileName);
+        const file = getFile(fileName);
+        const exists = () => file.text !== undefined || file.stat?.type === 1;
+        if (exists()) {
+            return true;
+        }
+        if (!file.requestedStat) {
+            file.requestedStat = true;
+            handleStat(fileName, file);
+        }
+        return exists();
+    }
+    function handleStat(fileName, file) {
+        const result = env.fs?.stat(env.fileNameToUri(fileName));
+        if (typeof result === 'object' && 'then' in result) {
+            const promise = result;
+            promises.add(promise);
+            result.then(result => {
+                promises.delete(promise);
+                if (file.stat?.type !== result?.type || file.stat?.mtime !== result?.mtime) {
+                    version++;
+                }
+                file.stat = result;
+            });
+        }
+        else {
+            file.stat = result;
+        }
+    }
+    function getFile(fileName) {
+        fileName = resolvePath(fileName);
+        const dirPath = path.dirname(fileName);
+        const baseName = path.basename(fileName);
+        const dir = getDir(dirPath);
+        let file = dir.files.get(baseName);
+        if (!file) {
+            dir.files.set(baseName, file = {});
+        }
+        return file;
+    }
+    // for import path completion
+    function getDirectories(dirName) {
+        dirName = resolvePath(dirName);
+        readDirectoryWorker(dirName);
+        const dir = getDir(dirName);
+        return [...dir.dirs.entries()].filter(([_, dir]) => dir.exists).map(([name]) => name);
+    }
+    function readDirectory(dirName, extensions, excludes, includes, depth) {
+        dirName = resolvePath(dirName);
+        const matches = (0, utilities_1.matchFiles)(dirName, extensions, excludes, includes, sys?.useCaseSensitiveFileNames ?? false, rootPath, depth, (dirPath) => {
+            dirPath = resolvePath(dirPath);
+            readDirectoryWorker(dirPath);
+            const dir = getDir(dirPath);
+            return {
+                files: [...dir.files.entries()].filter(([_, file]) => file.stat?.type === 1).map(([name]) => name),
+                directories: [...dir.dirs.entries()].filter(([_, dir]) => dir.exists).map(([name]) => name),
+            };
+        }, sys?.realpath ? (path => sys.realpath(path)) : (path => path));
+        return [...new Set(matches)];
+    }
+    function readFileWorker(fileName, encoding, dir) {
+        const name = path.basename(fileName);
+        let file = dir.files.get(name);
+        if (!file) {
+            dir.files.set(name, file = {});
+        }
+        if (file.requestedText) {
+            return;
+        }
+        file.requestedText = true;
+        const uri = env.fileNameToUri(fileName);
+        const result = env.fs?.readFile(uri, encoding);
+        if (typeof result === 'object' && 'then' in result) {
+            const promise = result;
+            promises.add(promise);
+            result.then(result => {
+                promises.delete(promise);
+                if (result !== undefined) {
+                    file.text = result;
+                    if (file.stat) {
+                        file.stat.mtime++;
+                    }
+                    version++;
+                }
+            });
+        }
+        else if (result !== undefined) {
+            file.text = result;
+        }
+    }
+    function readDirectoryWorker(dirName) {
+        const dir = getDir(dirName);
+        if (dir.requestedRead) {
+            return;
+        }
+        dir.requestedRead = true;
+        const result = env.fs?.readDirectory(env.fileNameToUri(dirName || '.'));
+        if (typeof result === 'object' && 'then' in result) {
+            const promise = result;
+            promises.add(promise);
+            result.then((result) => {
+                promises.delete(promise);
+                if (onReadDirectoryResult(dirName, dir, result)) {
+                    version++;
+                }
+            });
+        }
+        else {
+            onReadDirectoryResult(dirName, dir, result ?? []);
+        }
+    }
+    function onReadDirectoryResult(dirName, dir, result) {
+        // See https://github.com/microsoft/TypeScript/blob/e1a9290051a3b0cbdfbadc3adbcc155a4641522a/src/compiler/sys.ts#L1853-L1857
+        result = result.filter(([name]) => name !== '.' && name !== '..');
+        let updated = false;
+        for (const [name, _fileType] of result) {
+            let fileType = _fileType;
+            if (fileType === 64) {
+                const stat = env.fs?.stat(env.fileNameToUri(dirName + '/' + name));
+                if (typeof stat === 'object' && 'then' in stat) {
+                    const promise = stat;
+                    promises.add(promise);
+                    stat.then((stat) => {
+                        promises.delete(promise);
+                        if (stat?.type === 1) {
+                            let file = dir.files.get(name);
+                            if (!file) {
+                                dir.files.set(name, file = {});
+                            }
+                            if (stat.type !== file.stat?.type || stat.mtime !== file.stat?.mtime) {
+                                version++;
+                            }
+                            file.stat = stat;
+                            file.requestedStat = true;
+                        }
+                        else if (stat?.type === 2) {
+                            const childDir = getDirFromDir(dir, name);
+                            if (!childDir.exists) {
+                                childDir.exists = true;
+                                version++;
+                            }
+                        }
+                    });
+                }
+                else if (stat) {
+                    fileType = stat.type;
+                }
+            }
+            if (fileType === 1) {
+                let file = dir.files.get(name);
+                if (!file) {
+                    dir.files.set(name, file = {});
+                }
+                if (!file.stat) {
+                    file.stat = {
+                        type: 1,
+                        mtime: 0,
+                        ctime: 0,
+                        size: 0,
+                    };
+                    updated = true;
+                }
+            }
+            else if (fileType === 2) {
+                const childDir = getDirFromDir(dir, name);
+                if (!childDir.exists) {
+                    childDir.exists = true;
+                    updated = true;
+                }
+            }
+        }
+        return updated;
+    }
+    function getDir(dirName) {
+        const dirNames = [];
+        let currentDirPath = dirName;
+        let currentDirName = path.basename(currentDirPath);
+        let lastDirPath;
+        while (lastDirPath !== currentDirPath) {
+            lastDirPath = currentDirPath;
+            dirNames.push(currentDirName);
+            currentDirPath = path.dirname(currentDirPath);
+            currentDirName = path.basename(currentDirPath);
+        }
+        let currentDir = root;
+        for (let i = dirNames.length - 1; i >= 0; i--) {
+            const nextDirName = dirNames[i];
+            currentDir = getDirFromDir(currentDir, nextDirName);
+        }
+        return currentDir;
+    }
+    function getDirFromDir(dir, name) {
+        let target = dir.dirs.get(name);
+        if (!target) {
+            dir.dirs.set(name, target = {
+                dirs: new Map(),
+                files: new Map(),
+            });
+        }
+        return target;
+    }
+}
+exports.createSys = createSys;
+//# sourceMappingURL=sys.js.map

node_modules/@volar/typescript/lib/typescript/core.d.ts

@@ -0,0 +1,84 @@
+import { Comparer, Comparison, SortedReadonlyArray } from "./corePublic";
+/**
+ * Iterates through `array` by index and performs the callback on each element of array until the callback
+ * returns a falsey value, then returns false.
+ * If no such value is found, the callback is applied to each element of array and `true` is returned.
+ */
+export declare function every<T>(array: readonly T[] | undefined, callback: (element: T, index: number) => boolean): boolean;
+/** Works like Array.prototype.findIndex, returning `-1` if no element satisfying the predicate is found. */
+export declare function findIndex<T>(array: readonly T[] | undefined, predicate: (element: T, index: number) => boolean, startIndex?: number): number;
+export declare function indexOfAnyCharCode(text: string, charCodes: readonly number[], start?: number): number;
+export declare function map<T, U>(array: readonly T[], f: (x: T, i: number) => U): U[];
+export declare function map<T, U>(array: readonly T[] | undefined, f: (x: T, i: number) => U): U[] | undefined;
+/**
+ * Flattens an array containing a mix of array or non-array elements.
+ *
+ * @param array The array to flatten.
+ */
+export declare function flatten<T>(array: T[][] | readonly (T | readonly T[] | undefined)[]): T[];
+/**
+ * Maps an array. If the mapped value is an array, it is spread into the result.
+ *
+ * @param array The array to map.
+ * @param mapfn The callback used to map the result into one or more values.
+ */
+export declare function flatMap<T, U>(array: readonly T[] | undefined, mapfn: (x: T, i: number) => U | readonly U[] | undefined): readonly U[];
+export declare function some<T>(array: readonly T[] | undefined): array is readonly T[];
+export declare function some<T>(array: readonly T[] | undefined, predicate: (value: T) => boolean): boolean;
+/**
+ * Returns a new sorted array.
+ */
+export declare function sort<T>(array: readonly T[], comparer?: Comparer<T>): SortedReadonlyArray<T>;
+/**
+ * Returns the last element of an array if non-empty, `undefined` otherwise.
+ */
+export declare function lastOrUndefined<T>(array: readonly T[] | undefined): T | undefined;
+export declare function last<T>(array: readonly T[]): T;
+/**
+ * Compare the equality of two strings using a case-sensitive ordinal comparison.
+ *
+ * Case-sensitive comparisons compare both strings one code-point at a time using the integer
+ * value of each code-point after applying `toUpperCase` to each string. We always map both
+ * strings to their upper-case form as some unicode characters do not properly round-trip to
+ * lowercase (such as `ẞ` (German sharp capital s)).
+ */
+export declare function equateStringsCaseInsensitive(a: string, b: string): boolean;
+/**
+ * Compare the equality of two strings using a case-sensitive ordinal comparison.
+ *
+ * Case-sensitive comparisons compare both strings one code-point at a time using the
+ * integer value of each code-point.
+ */
+export declare function equateStringsCaseSensitive(a: string, b: string): boolean;
+/**
+ * Compare two strings using a case-insensitive ordinal comparison.
+ *
+ * Ordinal comparisons are based on the difference between the unicode code points of both
+ * strings. Characters with multiple unicode representations are considered unequal. Ordinal
+ * comparisons provide predictable ordering, but place "a" after "B".
+ *
+ * Case-insensitive comparisons compare both strings one code-point at a time using the integer
+ * value of each code-point after applying `toUpperCase` to each string. We always map both
+ * strings to their upper-case form as some unicode characters do not properly round-trip to
+ * lowercase (such as `ẞ` (German sharp capital s)).
+ */
+declare function compareStringsCaseInsensitive(a: string, b: string): Comparison;
+/**
+ * Compare two strings using a case-sensitive ordinal comparison.
+ *
+ * Ordinal comparisons are based on the difference between the unicode code points of both
+ * strings. Characters with multiple unicode representations are considered unequal. Ordinal
+ * comparisons provide predictable ordering, but place "a" after "B".
+ *
+ * Case-sensitive comparisons compare both strings one code-point at a time using the integer
+ * value of each code-point.
+ */
+export declare function compareStringsCaseSensitive(a: string | undefined, b: string | undefined): Comparison;
+export declare function getStringComparer(ignoreCase?: boolean): typeof compareStringsCaseInsensitive;
+export declare function endsWith(str: string, suffix: string): boolean;
+export declare function stringContains(str: string, substring: string): boolean;
+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

node_modules/@volar/typescript/lib/typescript/core.js

@@ -0,0 +1,320 @@
+"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;
+const emptyArray = [];
+/**
+ * Iterates through `array` by index and performs the callback on each element of array until the callback
+ * returns a falsey value, then returns false.
+ * If no such value is found, the callback is applied to each element of array and `true` is returned.
+ */
+function every(array, callback) {
+    if (array) {
+        for (let i = 0; i < array.length; i++) {
+            if (!callback(array[i], i)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+exports.every = every;
+/** Works like Array.prototype.findIndex, returning `-1` if no element satisfying the predicate is found. */
+function findIndex(array, predicate, startIndex) {
+    if (array === undefined)
+        return -1;
+    for (let i = startIndex ?? 0; i < array.length; i++) {
+        if (predicate(array[i], i)) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.findIndex = findIndex;
+function contains(array, value, equalityComparer = equateValues) {
+    if (array) {
+        for (const v of array) {
+            if (equalityComparer(v, value)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function indexOfAnyCharCode(text, charCodes, start) {
+    for (let i = start || 0; i < text.length; i++) {
+        if (contains(charCodes, text.charCodeAt(i))) {
+            return i;
+        }
+    }
+    return -1;
+}
+exports.indexOfAnyCharCode = indexOfAnyCharCode;
+function map(array, f) {
+    let result;
+    if (array) {
+        result = [];
+        for (let i = 0; i < array.length; i++) {
+            result.push(f(array[i], i));
+        }
+    }
+    return result;
+}
+exports.map = map;
+/**
+ * Flattens an array containing a mix of array or non-array elements.
+ *
+ * @param array The array to flatten.
+ */
+function flatten(array) {
+    const result = [];
+    for (const v of array) {
+        if (v) {
+            if (isArray(v)) {
+                addRange(result, v);
+            }
+            else {
+                result.push(v);
+            }
+        }
+    }
+    return result;
+}
+exports.flatten = flatten;
+/**
+ * Maps an array. If the mapped value is an array, it is spread into the result.
+ *
+ * @param array The array to map.
+ * @param mapfn The callback used to map the result into one or more values.
+ */
+function flatMap(array, mapfn) {
+    let result;
+    if (array) {
+        for (let i = 0; i < array.length; i++) {
+            const v = mapfn(array[i], i);
+            if (v) {
+                if (isArray(v)) {
+                    result = addRange(result, v);
+                }
+                else {
+                    result = append(result, v);
+                }
+            }
+        }
+    }
+    return result || emptyArray;
+}
+exports.flatMap = flatMap;
+function some(array, predicate) {
+    if (array) {
+        if (predicate) {
+            for (const v of array) {
+                if (predicate(v)) {
+                    return true;
+                }
+            }
+        }
+        else {
+            return array.length > 0;
+        }
+    }
+    return false;
+}
+exports.some = some;
+// function append<T>(to: T[] | undefined, value: T): T[];
+// function append<T>(to: T[] | undefined, value: T | undefined): T[] | undefined;
+// function append<T>(to: Push<T>, value: T | undefined): void;
+function append(to, value) {
+    if (value === undefined)
+        return to;
+    if (to === undefined)
+        return [value];
+    to.push(value);
+    return to;
+}
+/**
+ * Gets the actual offset into an array for a relative offset. Negative offsets indicate a
+ * position offset from the end of the array.
+ */
+function toOffset(array, offset) {
+    return offset < 0 ? array.length + offset : offset;
+}
+function addRange(to, from, start, end) {
+    if (from === undefined || from.length === 0)
+        return to;
+    if (to === undefined)
+        return from.slice(start, end);
+    start = start === undefined ? 0 : toOffset(from, start);
+    end = end === undefined ? from.length : toOffset(from, end);
+    for (let i = start; i < end && i < from.length; i++) {
+        if (from[i] !== undefined) {
+            to.push(from[i]);
+        }
+    }
+    return to;
+}
+/**
+ * Returns a new sorted array.
+ */
+function sort(array, comparer) {
+    return (array.length === 0 ? array : array.slice().sort(comparer));
+}
+exports.sort = sort;
+/**
+ * Returns the last element of an array if non-empty, `undefined` otherwise.
+ */
+function lastOrUndefined(array) {
+    return array === undefined || array.length === 0 ? undefined : array[array.length - 1];
+}
+exports.lastOrUndefined = lastOrUndefined;
+function last(array) {
+    // Debug.assert(array.length !== 0);
+    return array[array.length - 1];
+}
+exports.last = last;
+/**
+ * Tests whether a value is an array.
+ */
+function isArray(value) {
+    return Array.isArray ? Array.isArray(value) : value instanceof Array;
+}
+/** Returns its argument. */
+function identity(x) {
+    return x;
+}
+/** Returns lower case string */
+function toLowerCase(x) {
+    return x.toLowerCase();
+}
+// We convert the file names to lower case as key for file name on case insensitive file system
+// While doing so we need to handle special characters (eg \u0130) to ensure that we dont convert
+// it to lower case, fileName with its lowercase form can exist along side it.
+// Handle special characters and make those case sensitive instead
+//
+// |-#--|-Unicode--|-Char code-|-Desc-------------------------------------------------------------------|
+// | 1. | i        | 105       | Ascii i                                                                |
+// | 2. | I        | 73        | Ascii I                                                                |
+// |-------- Special characters ------------------------------------------------------------------------|
+// | 3. | \u0130   | 304       | Upper case I with dot above                                            |
+// | 4. | i,\u0307 | 105,775   | i, followed by 775: Lower case of (3rd item)                           |
+// | 5. | I,\u0307 | 73,775    | I, followed by 775: Upper case of (4th item), lower case is (4th item) |
+// | 6. | \u0131   | 305       | Lower case i without dot, upper case is I (2nd item)                   |
+// | 7. | \u00DF   | 223       | Lower case sharp s                                                     |
+//
+// Because item 3 is special where in its lowercase character has its own
+// upper case form we cant convert its case.
+// Rest special characters are either already in lower case format or
+// they have corresponding upper case character so they dont need special handling
+//
+// But to avoid having to do string building for most common cases, also ignore
+// a-z, 0-9, \u0131, \u00DF, \, /, ., : and space
+const fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
+/**
+ * Case insensitive file systems have descripencies in how they handle some characters (eg. turkish Upper case I with dot on top - \u0130)
+ * This function is used in places where we want to make file name as a key on these systems
+ * It is possible on mac to be able to refer to file name with I with dot on top as a fileName with its lower case form
+ * But on windows we cannot. Windows can have fileName with I with dot on top next to its lower case and they can not each be referred with the lowercase forms
+ * Technically we would want this function to be platform sepcific as well but
+ * our api has till now only taken caseSensitive as the only input and just for some characters we dont want to update API and ensure all customers use those api
+ * We could use upper case and we would still need to deal with the descripencies but
+ * we want to continue using lower case since in most cases filenames are lowercasewe and wont need any case changes and avoid having to store another string for the key
+ * So for this function purpose, we go ahead and assume character I with dot on top it as case sensitive since its very unlikely to use lower case form of that special character
+ */
+function toFileNameLowerCase(x) {
+    return fileNameLowerCaseRegExp.test(x) ?
+        x.replace(fileNameLowerCaseRegExp, toLowerCase) :
+        x;
+}
+function equateValues(a, b) {
+    return a === b;
+}
+/**
+ * Compare the equality of two strings using a case-sensitive ordinal comparison.
+ *
+ * Case-sensitive comparisons compare both strings one code-point at a time using the integer
+ * value of each code-point after applying `toUpperCase` to each string. We always map both
+ * strings to their upper-case form as some unicode characters do not properly round-trip to
+ * lowercase (such as `ẞ` (German sharp capital s)).
+ */
+function equateStringsCaseInsensitive(a, b) {
+    return a === b
+        || a !== undefined
+            && b !== undefined
+            && a.toUpperCase() === b.toUpperCase();
+}
+exports.equateStringsCaseInsensitive = equateStringsCaseInsensitive;
+/**
+ * Compare the equality of two strings using a case-sensitive ordinal comparison.
+ *
+ * Case-sensitive comparisons compare both strings one code-point at a time using the
+ * integer value of each code-point.
+ */
+function equateStringsCaseSensitive(a, b) {
+    return equateValues(a, b);
+}
+exports.equateStringsCaseSensitive = equateStringsCaseSensitive;
+function compareComparableValues(a, b) {
+    return a === b ? 0 /* Comparison.EqualTo */ :
+        a === undefined ? -1 /* Comparison.LessThan */ :
+            b === undefined ? 1 /* Comparison.GreaterThan */ :
+                a < b ? -1 /* Comparison.LessThan */ :
+                    1 /* Comparison.GreaterThan */;
+}
+/**
+ * Compare two strings using a case-insensitive ordinal comparison.
+ *
+ * Ordinal comparisons are based on the difference between the unicode code points of both
+ * strings. Characters with multiple unicode representations are considered unequal. Ordinal
+ * comparisons provide predictable ordering, but place "a" after "B".
+ *
+ * Case-insensitive comparisons compare both strings one code-point at a time using the integer
+ * value of each code-point after applying `toUpperCase` to each string. We always map both
+ * strings to their upper-case form as some unicode characters do not properly round-trip to
+ * lowercase (such as `ẞ` (German sharp capital s)).
+ */
+function compareStringsCaseInsensitive(a, b) {
+    if (a === b)
+        return 0 /* Comparison.EqualTo */;
+    if (a === undefined)
+        return -1 /* Comparison.LessThan */;
+    if (b === undefined)
+        return 1 /* Comparison.GreaterThan */;
+    a = a.toUpperCase();
+    b = b.toUpperCase();
+    return a < b ? -1 /* Comparison.LessThan */ : a > b ? 1 /* Comparison.GreaterThan */ : 0 /* Comparison.EqualTo */;
+}
+/**
+ * Compare two strings using a case-sensitive ordinal comparison.
+ *
+ * Ordinal comparisons are based on the difference between the unicode code points of both
+ * strings. Characters with multiple unicode representations are considered unequal. Ordinal
+ * comparisons provide predictable ordering, but place "a" after "B".
+ *
+ * Case-sensitive comparisons compare both strings one code-point at a time using the integer
+ * value of each code-point.
+ */
+function compareStringsCaseSensitive(a, b) {
+    return compareComparableValues(a, b);
+}
+exports.compareStringsCaseSensitive = compareStringsCaseSensitive;
+function getStringComparer(ignoreCase) {
+    return ignoreCase ? compareStringsCaseInsensitive : compareStringsCaseSensitive;
+}
+exports.getStringComparer = getStringComparer;
+function endsWith(str, suffix) {
+    const expectedPos = str.length - suffix.length;
+    return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos;
+}
+exports.endsWith = endsWith;
+function stringContains(str, substring) {
+    return str.indexOf(substring) !== -1;
+}
+exports.stringContains = stringContains;
+function createGetCanonicalFileName(useCaseSensitiveFileNames) {
+    return useCaseSensitiveFileNames ? identity : toFileNameLowerCase;
+}
+exports.createGetCanonicalFileName = createGetCanonicalFileName;
+function startsWith(str, prefix) {
+    return str.lastIndexOf(prefix, 0) === 0;
+}
+exports.startsWith = startsWith;
+//# sourceMappingURL=core.js.map

node_modules/@volar/typescript/lib/typescript/corePublic.d.ts

@@ -0,0 +1,92 @@
+export declare const versionMajorMinor = "4.9";
+/** The version of the TypeScript compiler release */
+export declare const version: string;
+/**
+ * Type of objects whose values are all of the same type.
+ * The `in` and `for-in` operators can *not* be safely used,
+ * since `Object.prototype` may be modified by outside code.
+ */
+export interface MapLike<T> {
+    [index: string]: T;
+}
+export interface SortedReadonlyArray<T> extends ReadonlyArray<T> {
+    " __sortedArrayBrand": any;
+}
+export interface SortedArray<T> extends Array<T> {
+    " __sortedArrayBrand": any;
+}
+/** Common read methods for ES6 Map/Set. */
+export interface ReadonlyCollection<K> {
+    readonly size: number;
+    has(key: K): boolean;
+    keys(): Iterator<K>;
+}
+/** Common write methods for ES6 Map/Set. */
+export interface Collection<K> extends ReadonlyCollection<K> {
+    delete(key: K): boolean;
+    clear(): void;
+}
+/** ES6 Map interface, only read methods included. */
+export interface ReadonlyESMap<K, V> extends ReadonlyCollection<K> {
+    get(key: K): V | undefined;
+    values(): Iterator<V>;
+    entries(): Iterator<[K, V]>;
+    forEach(action: (value: V, key: K) => void): void;
+}
+/**
+ * ES6 Map interface, only read methods included.
+ */
+export interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
+}
+/** ES6 Map interface. */
+export interface ESMap<K, V> extends ReadonlyESMap<K, V>, Collection<K> {
+    set(key: K, value: V): this;
+}
+/**
+ * ES6 Map interface.
+ */
+export interface Map<T> extends ESMap<string, T> {
+}
+export interface MapConstructor {
+    new <K, V>(iterable?: readonly (readonly [K, V])[] | ReadonlyESMap<K, V>): ESMap<K, V>;
+}
+/** ES6 Set interface, only read methods included. */
+export interface ReadonlySet<T> extends ReadonlyCollection<T> {
+    has(value: T): boolean;
+    values(): Iterator<T>;
+    entries(): Iterator<[T, T]>;
+    forEach(action: (value: T, key: T) => void): void;
+}
+/** ES6 Set interface. */
+export interface Set<T> extends ReadonlySet<T>, Collection<T> {
+    add(value: T): this;
+    delete(value: T): boolean;
+}
+export interface SetConstructor {
+    new <T>(iterable?: readonly T[] | ReadonlySet<T>): Set<T>;
+}
+/** ES6 Iterator type. */
+export interface Iterator<T> {
+    next(): {
+        value: T;
+        done?: false;
+    } | {
+        value: void;
+        done: true;
+    };
+}
+/** Array that is only intended to be pushed to, never read. */
+export interface Push<T> {
+    push(...values: T[]): void;
+    readonly length: number;
+}
+export type EqualityComparer<T> = (a: T, b: T) => boolean;
+export type Comparer<T> = (a: T, b: T) => Comparison;
+export declare const enum Comparison {
+    LessThan = -1,
+    EqualTo = 0,
+    GreaterThan = 1
+}
+export declare const Map: MapConstructor;
+export declare const Set: SetConstructor;
+//# sourceMappingURL=corePublic.d.ts.map

node_modules/@volar/typescript/lib/typescript/corePublic.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Set = exports.Map = exports.version = exports.versionMajorMinor = void 0;
+// WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values.
+// If changing the text in this section, be sure to test `configurePrerelease` too.
+exports.versionMajorMinor = "4.9";
+// The following is baselined as a literal template type without intervention
+/** The version of the TypeScript compiler release */
+// eslint-disable-next-line @typescript-eslint/no-inferrable-types
+exports.version = `${exports.versionMajorMinor}.0-dev`;
+/* @internal */
+var NativeCollections;
+(function (NativeCollections) {
+    const globals = typeof globalThis !== "undefined" ? globalThis :
+        // @ts-expect-error node global
+        typeof global !== "undefined" ? global :
+            typeof self !== "undefined" ? self :
+                undefined;
+    /**
+     * Returns the native Map implementation if it is available and compatible (i.e. supports iteration).
+     */
+    function tryGetNativeMap() {
+        // Internet Explorer's Map doesn't support iteration, so don't use it.
+        const gMap = globals?.Map;
+        // eslint-disable-next-line local/no-in-operator
+        const constructor = typeof gMap !== "undefined" && "entries" in gMap.prototype && new gMap([[0, 0]]).size === 1 ? gMap : undefined;
+        if (!constructor) {
+            throw new Error("No compatible Map implementation found.");
+        }
+        return constructor;
+    }
+    NativeCollections.tryGetNativeMap = tryGetNativeMap;
+    /**
+     * Returns the native Set implementation if it is available and compatible (i.e. supports iteration).
+     */
+    function tryGetNativeSet() {
+        // Internet Explorer's Set doesn't support iteration, so don't use it.
+        const gSet = globals?.Set;
+        // eslint-disable-next-line local/no-in-operator
+        const constructor = typeof gSet !== "undefined" && "entries" in gSet.prototype && new gSet([0]).size === 1 ? gSet : undefined;
+        if (!constructor) {
+            throw new Error("No compatible Set implementation found.");
+        }
+        return constructor;
+    }
+    NativeCollections.tryGetNativeSet = tryGetNativeSet;
+})(NativeCollections || (NativeCollections = {}));
+/* @internal */
+exports.Map = NativeCollections.tryGetNativeMap();
+/* @internal */
+exports.Set = NativeCollections.tryGetNativeSet();
+//# sourceMappingURL=corePublic.js.map

node_modules/@volar/typescript/lib/typescript/path.d.ts

@@ -0,0 +1,113 @@
+import { Path } from "./types";
+/**
+ * Internally, we represent paths as strings with '/' as the directory separator.
+ * When we make system calls (eg: LanguageServiceHost.getDirectory()),
+ * we expect the host to correctly handle paths in our specified format.
+ */
+export declare const directorySeparator = "/";
+/**
+ * Determines whether a path is an absolute disk path (e.g. starts with `/`, or a dos path
+ * like `c:`, `c:\` or `c:/`).
+ */
+export declare function isRootedDiskPath(path: string): boolean;
+export declare function hasExtension(fileName: string): boolean;
+export declare function fileExtensionIsOneOf(path: string, extensions: readonly string[]): boolean;
+/**
+ * Returns the path except for its basename. Semantics align with NodeJS's `path.dirname`
+ * except that we support URLs as well.
+ *
+ * ```ts
+ * // POSIX
+ * getDirectoryPath("/path/to/file.ext") === "/path/to"
+ * getDirectoryPath("/path/to/") === "/path"
+ * getDirectoryPath("/") === "/"
+ * // DOS
+ * getDirectoryPath("c:/path/to/file.ext") === "c:/path/to"
+ * getDirectoryPath("c:/path/to/") === "c:/path"
+ * getDirectoryPath("c:/") === "c:/"
+ * getDirectoryPath("c:") === "c:"
+ * // URL
+ * getDirectoryPath("http://typescriptlang.org/path/to/file.ext") === "http://typescriptlang.org/path/to"
+ * getDirectoryPath("http://typescriptlang.org/path/to") === "http://typescriptlang.org/path"
+ * getDirectoryPath("http://typescriptlang.org/") === "http://typescriptlang.org/"
+ * getDirectoryPath("http://typescriptlang.org") === "http://typescriptlang.org"
+ * ```
+ */
+export declare function getDirectoryPath(path: Path): Path;
+/**
+ * Returns the path except for its basename. Semantics align with NodeJS's `path.dirname`
+ * except that we support URLs as well.
+ *
+ * ```ts
+ * // POSIX
+ * getDirectoryPath("/path/to/file.ext") === "/path/to"
+ * getDirectoryPath("/path/to/") === "/path"
+ * getDirectoryPath("/") === "/"
+ * // DOS
+ * getDirectoryPath("c:/path/to/file.ext") === "c:/path/to"
+ * getDirectoryPath("c:/path/to/") === "c:/path"
+ * getDirectoryPath("c:/") === "c:/"
+ * getDirectoryPath("c:") === "c:"
+ * // URL
+ * getDirectoryPath("http://typescriptlang.org/path/to/file.ext") === "http://typescriptlang.org/path/to"
+ * getDirectoryPath("http://typescriptlang.org/path/to") === "http://typescriptlang.org/path"
+ * getDirectoryPath("http://typescriptlang.org/") === "http://typescriptlang.org/"
+ * getDirectoryPath("http://typescriptlang.org") === "http://typescriptlang.org"
+ * getDirectoryPath("file://server/path/to/file.ext") === "file://server/path/to"
+ * getDirectoryPath("file://server/path/to") === "file://server/path"
+ * getDirectoryPath("file://server/") === "file://server/"
+ * getDirectoryPath("file://server") === "file://server"
+ * getDirectoryPath("file:///path/to/file.ext") === "file:///path/to"
+ * getDirectoryPath("file:///path/to") === "file:///path"
+ * getDirectoryPath("file:///") === "file:///"
+ * getDirectoryPath("file://") === "file://"
+ * ```
+ */
+export declare function getDirectoryPath(path: string): string;
+/**
+ * Combines paths. If a path is absolute, it replaces any previous path. Relative paths are not simplified.
+ *
+ * ```ts
+ * // Non-rooted
+ * combinePaths("path", "to", "file.ext") === "path/to/file.ext"
+ * combinePaths("path", "dir", "..", "to", "file.ext") === "path/dir/../to/file.ext"
+ * // POSIX
+ * combinePaths("/path", "to", "file.ext") === "/path/to/file.ext"
+ * combinePaths("/path", "/to", "file.ext") === "/to/file.ext"
+ * // DOS
+ * combinePaths("c:/path", "to", "file.ext") === "c:/path/to/file.ext"
+ * combinePaths("c:/path", "c:/to", "file.ext") === "c:/to/file.ext"
+ * // URL
+ * combinePaths("file:///path", "to", "file.ext") === "file:///path/to/file.ext"
+ * combinePaths("file:///path", "file:///to", "file.ext") === "file:///to/file.ext"
+ * ```
+ */
+export declare function combinePaths(path: string, ...paths: (string | undefined)[]): string;
+/**
+ * Parse a path into an array containing a root component (at index 0) and zero or more path
+ * components (at indices > 0). The result is normalized.
+ * If the path is relative, the root component is `""`.
+ * If the path is absolute, the root component includes the first path separator (`/`).
+ *
+ * ```ts
+ * getNormalizedPathComponents("to/dir/../file.ext", "/path/") === ["/", "path", "to", "file.ext"]
+ * ```
+ */
+export declare function getNormalizedPathComponents(path: string, currentDirectory: string | undefined): string[];
+export declare function normalizePath(path: string): string;
+/**
+ * Removes a trailing directory separator from a path, if it does not already have one.
+ *
+ * ```ts
+ * removeTrailingDirectorySeparator("/path/to/file.ext") === "/path/to/file.ext"
+ * removeTrailingDirectorySeparator("/path/to/file.ext/") === "/path/to/file.ext"
+ * ```
+ */
+export declare function removeTrailingDirectorySeparator(path: Path): Path;
+export declare function removeTrailingDirectorySeparator(path: string): string;
+/**
+ * Determines whether a `parent` path contains a `child` path using the provide case sensitivity.
+ */
+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

node_modules/@volar/typescript/lib/typescript/path.js

@@ -0,0 +1,417 @@
+"use strict";
+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");
+/**
+ * Internally, we represent paths as strings with '/' as the directory separator.
+ * When we make system calls (eg: LanguageServiceHost.getDirectory()),
+ * we expect the host to correctly handle paths in our specified format.
+ */
+exports.directorySeparator = "/";
+const altDirectorySeparator = "\\";
+const urlSchemeSeparator = "://";
+const backslashRegExp = /\\/g;
+//// Path Tests
+/**
+ * Determines whether a charCode corresponds to `/` or `\`.
+ */
+function isAnyDirectorySeparator(charCode) {
+    return charCode === 47 /* CharacterCodes.slash */ || charCode === 92 /* CharacterCodes.backslash */;
+}
+/**
+ * Determines whether a path is an absolute disk path (e.g. starts with `/`, or a dos path
+ * like `c:`, `c:\` or `c:/`).
+ */
+function isRootedDiskPath(path) {
+    return getEncodedRootLength(path) > 0;
+}
+exports.isRootedDiskPath = isRootedDiskPath;
+function hasExtension(fileName) {
+    return (0, core_1.stringContains)(getBaseFileName(fileName), ".");
+}
+exports.hasExtension = hasExtension;
+function fileExtensionIs(path, extension) {
+    return path.length > extension.length && (0, core_1.endsWith)(path, extension);
+}
+function fileExtensionIsOneOf(path, extensions) {
+    for (const extension of extensions) {
+        if (fileExtensionIs(path, extension)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.fileExtensionIsOneOf = fileExtensionIsOneOf;
+/**
+ * Determines whether a path has a trailing separator (`/` or `\\`).
+ */
+function hasTrailingDirectorySeparator(path) {
+    return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
+}
+//// Path Parsing
+function isVolumeCharacter(charCode) {
+    return (charCode >= 97 /* CharacterCodes.a */ && charCode <= 122 /* CharacterCodes.z */) ||
+        (charCode >= 65 /* CharacterCodes.A */ && charCode <= 90 /* CharacterCodes.Z */);
+}
+function getFileUrlVolumeSeparatorEnd(url, start) {
+    const ch0 = url.charCodeAt(start);
+    if (ch0 === 58 /* CharacterCodes.colon */)
+        return start + 1;
+    if (ch0 === 37 /* CharacterCodes.percent */ && url.charCodeAt(start + 1) === 51 /* CharacterCodes._3 */) {
+        const ch2 = url.charCodeAt(start + 2);
+        if (ch2 === 97 /* CharacterCodes.a */ || ch2 === 65 /* CharacterCodes.A */)
+            return start + 3;
+    }
+    return -1;
+}
+/**
+ * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
+ * If the root is part of a URL, the twos-complement of the root length is returned.
+ */
+function getEncodedRootLength(path) {
+    if (!path)
+        return 0;
+    const ch0 = path.charCodeAt(0);
+    // POSIX or UNC
+    if (ch0 === 47 /* CharacterCodes.slash */ || ch0 === 92 /* CharacterCodes.backslash */) {
+        if (path.charCodeAt(1) !== ch0)
+            return 1; // POSIX: "/" (or non-normalized "\")
+        const p1 = path.indexOf(ch0 === 47 /* CharacterCodes.slash */ ? exports.directorySeparator : altDirectorySeparator, 2);
+        if (p1 < 0)
+            return path.length; // UNC: "//server" or "\\server"
+        return p1 + 1; // UNC: "//server/" or "\\server\"
+    }
+    // DOS
+    if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58 /* CharacterCodes.colon */) {
+        const ch2 = path.charCodeAt(2);
+        if (ch2 === 47 /* CharacterCodes.slash */ || ch2 === 92 /* CharacterCodes.backslash */)
+            return 3; // DOS: "c:/" or "c:\"
+        if (path.length === 2)
+            return 2; // DOS: "c:" (but not "c:d")
+    }
+    // URL
+    const schemeEnd = path.indexOf(urlSchemeSeparator);
+    if (schemeEnd !== -1) {
+        const authorityStart = schemeEnd + urlSchemeSeparator.length;
+        const authorityEnd = path.indexOf(exports.directorySeparator, authorityStart);
+        if (authorityEnd !== -1) { // URL: "file:///", "file://server/", "file://server/path"
+            // For local "file" URLs, include the leading DOS volume (if present).
+            // Per https://www.ietf.org/rfc/rfc1738.txt, a host of "" or "localhost" is a
+            // special case interpreted as "the machine from which the URL is being interpreted".
+            const scheme = path.slice(0, schemeEnd);
+            const authority = path.slice(authorityStart, authorityEnd);
+            if (scheme === "file" && (authority === "" || authority === "localhost") &&
+                isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
+                const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
+                if (volumeSeparatorEnd !== -1) {
+                    if (path.charCodeAt(volumeSeparatorEnd) === 47 /* CharacterCodes.slash */) {
+                        // URL: "file:///c:/", "file://localhost/c:/", "file:///c%3a/", "file://localhost/c%3a/"
+                        return ~(volumeSeparatorEnd + 1);
+                    }
+                    if (volumeSeparatorEnd === path.length) {
+                        // URL: "file:///c:", "file://localhost/c:", "file:///c$3a", "file://localhost/c%3a"
+                        // but not "file:///c:d" or "file:///c%3ad"
+                        return ~volumeSeparatorEnd;
+                    }
+                }
+            }
+            return ~(authorityEnd + 1); // URL: "file://server/", "http://server/"
+        }
+        return ~path.length; // URL: "file://server", "http://server"
+    }
+    // relative
+    return 0;
+}
+/**
+ * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
+ *
+ * For example:
+ * ```ts
+ * getRootLength("a") === 0                   // ""
+ * getRootLength("/") === 1                   // "/"
+ * getRootLength("c:") === 2                  // "c:"
+ * getRootLength("c:d") === 0                 // ""
+ * getRootLength("c:/") === 3                 // "c:/"
+ * getRootLength("c:\\") === 3                // "c:\\"
+ * getRootLength("//server") === 7            // "//server"
+ * getRootLength("//server/share") === 8      // "//server/"
+ * getRootLength("\\\\server") === 7          // "\\\\server"
+ * getRootLength("\\\\server\\share") === 8   // "\\\\server\\"
+ * getRootLength("file:///path") === 8        // "file:///"
+ * getRootLength("file:///c:") === 10         // "file:///c:"
+ * getRootLength("file:///c:d") === 8         // "file:///"
+ * getRootLength("file:///c:/path") === 11    // "file:///c:/"
+ * getRootLength("file://server") === 13      // "file://server"
+ * getRootLength("file://server/path") === 14 // "file://server/"
+ * getRootLength("http://server") === 13      // "http://server"
+ * getRootLength("http://server/path") === 14 // "http://server/"
+ * ```
+ */
+function getRootLength(path) {
+    const rootLength = getEncodedRootLength(path);
+    return rootLength < 0 ? ~rootLength : rootLength;
+}
+function getDirectoryPath(path) {
+    path = normalizeSlashes(path);
+    // If the path provided is itself the root, then return it.
+    const rootLength = getRootLength(path);
+    if (rootLength === path.length)
+        return path;
+    // return the leading portion of the path up to the last (non-terminal) directory separator
+    // but not including any trailing directory separator.
+    path = removeTrailingDirectorySeparator(path);
+    return path.slice(0, Math.max(rootLength, path.lastIndexOf(exports.directorySeparator)));
+}
+exports.getDirectoryPath = getDirectoryPath;
+function getBaseFileName(path, extensions, ignoreCase) {
+    path = normalizeSlashes(path);
+    // if the path provided is itself the root, then it has not file name.
+    const rootLength = getRootLength(path);
+    if (rootLength === path.length)
+        return "";
+    // return the trailing portion of the path starting after the last (non-terminal) directory
+    // separator but not including any trailing directory separator.
+    path = removeTrailingDirectorySeparator(path);
+    const name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(exports.directorySeparator) + 1));
+    const extension = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(name, extensions, ignoreCase) : undefined;
+    return extension ? name.slice(0, name.length - extension.length) : name;
+}
+function tryGetExtensionFromPath(path, extension, stringEqualityComparer) {
+    if (!(0, core_1.startsWith)(extension, "."))
+        extension = "." + extension;
+    if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46 /* CharacterCodes.dot */) {
+        const pathExtension = path.slice(path.length - extension.length);
+        if (stringEqualityComparer(pathExtension, extension)) {
+            return pathExtension;
+        }
+    }
+}
+function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) {
+    if (typeof extensions === "string") {
+        return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || "";
+    }
+    for (const extension of extensions) {
+        const result = tryGetExtensionFromPath(path, extension, stringEqualityComparer);
+        if (result)
+            return result;
+    }
+    return "";
+}
+function getAnyExtensionFromPath(path, extensions, ignoreCase) {
+    // Retrieves any string from the final "." onwards from a base file name.
+    // Unlike extensionFromPath, which throws an exception on unrecognized extensions.
+    if (extensions) {
+        return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? core_1.equateStringsCaseInsensitive : core_1.equateStringsCaseSensitive);
+    }
+    const baseFileName = getBaseFileName(path);
+    const extensionIndex = baseFileName.lastIndexOf(".");
+    if (extensionIndex >= 0) {
+        return baseFileName.substring(extensionIndex);
+    }
+    return "";
+}
+function pathComponents(path, rootLength) {
+    const root = path.substring(0, rootLength);
+    const rest = path.substring(rootLength).split(exports.directorySeparator);
+    if (rest.length && !(0, core_1.lastOrUndefined)(rest))
+        rest.pop();
+    return [root, ...rest];
+}
+/**
+ * Parse a path into an array containing a root component (at index 0) and zero or more path
+ * components (at indices > 0). The result is not normalized.
+ * If the path is relative, the root component is `""`.
+ * If the path is absolute, the root component includes the first path separator (`/`).
+ *
+ * ```ts
+ * // POSIX
+ * getPathComponents("/path/to/file.ext") === ["/", "path", "to", "file.ext"]
+ * getPathComponents("/path/to/") === ["/", "path", "to"]
+ * getPathComponents("/") === ["/"]
+ * // DOS
+ * getPathComponents("c:/path/to/file.ext") === ["c:/", "path", "to", "file.ext"]
+ * getPathComponents("c:/path/to/") === ["c:/", "path", "to"]
+ * getPathComponents("c:/") === ["c:/"]
+ * getPathComponents("c:") === ["c:"]
+ * // URL
+ * getPathComponents("http://typescriptlang.org/path/to/file.ext") === ["http://typescriptlang.org/", "path", "to", "file.ext"]
+ * getPathComponents("http://typescriptlang.org/path/to/") === ["http://typescriptlang.org/", "path", "to"]
+ * getPathComponents("http://typescriptlang.org/") === ["http://typescriptlang.org/"]
+ * getPathComponents("http://typescriptlang.org") === ["http://typescriptlang.org"]
+ * getPathComponents("file://server/path/to/file.ext") === ["file://server/", "path", "to", "file.ext"]
+ * getPathComponents("file://server/path/to/") === ["file://server/", "path", "to"]
+ * getPathComponents("file://server/") === ["file://server/"]
+ * getPathComponents("file://server") === ["file://server"]
+ * getPathComponents("file:///path/to/file.ext") === ["file:///", "path", "to", "file.ext"]
+ * getPathComponents("file:///path/to/") === ["file:///", "path", "to"]
+ * getPathComponents("file:///") === ["file:///"]
+ * getPathComponents("file://") === ["file://"]
+ */
+function getPathComponents(path, currentDirectory = "") {
+    path = combinePaths(currentDirectory, path);
+    return pathComponents(path, getRootLength(path));
+}
+//// Path Formatting
+/**
+ * Formats a parsed path consisting of a root component (at index 0) and zero or more path
+ * segments (at indices > 0).
+ *
+ * ```ts
+ * getPathFromPathComponents(["/", "path", "to", "file.ext"]) === "/path/to/file.ext"
+ * ```
+ */
+function getPathFromPathComponents(pathComponents) {
+    if (pathComponents.length === 0)
+        return "";
+    const root = pathComponents[0] && ensureTrailingDirectorySeparator(pathComponents[0]);
+    return root + pathComponents.slice(1).join(exports.directorySeparator);
+}
+//// Path Normalization
+/**
+ * Normalize path separators, converting `\` into `/`.
+ */
+function normalizeSlashes(path) {
+    return path.indexOf("\\") !== -1
+        ? path.replace(backslashRegExp, exports.directorySeparator)
+        : path;
+}
+/**
+ * Reduce an array of path components to a more simplified path by navigating any
+ * `"."` or `".."` entries in the path.
+ */
+function reducePathComponents(components) {
+    if (!(0, core_1.some)(components))
+        return [];
+    const reduced = [components[0]];
+    for (let i = 1; i < components.length; i++) {
+        const component = components[i];
+        if (!component)
+            continue;
+        if (component === ".")
+            continue;
+        if (component === "..") {
+            if (reduced.length > 1) {
+                if (reduced[reduced.length - 1] !== "..") {
+                    reduced.pop();
+                    continue;
+                }
+            }
+            else if (reduced[0])
+                continue;
+        }
+        reduced.push(component);
+    }
+    return reduced;
+}
+/**
+ * Combines paths. If a path is absolute, it replaces any previous path. Relative paths are not simplified.
+ *
+ * ```ts
+ * // Non-rooted
+ * combinePaths("path", "to", "file.ext") === "path/to/file.ext"
+ * combinePaths("path", "dir", "..", "to", "file.ext") === "path/dir/../to/file.ext"
+ * // POSIX
+ * combinePaths("/path", "to", "file.ext") === "/path/to/file.ext"
+ * combinePaths("/path", "/to", "file.ext") === "/to/file.ext"
+ * // DOS
+ * combinePaths("c:/path", "to", "file.ext") === "c:/path/to/file.ext"
+ * combinePaths("c:/path", "c:/to", "file.ext") === "c:/to/file.ext"
+ * // URL
+ * combinePaths("file:///path", "to", "file.ext") === "file:///path/to/file.ext"
+ * combinePaths("file:///path", "file:///to", "file.ext") === "file:///to/file.ext"
+ * ```
+ */
+function combinePaths(path, ...paths) {
+    if (path)
+        path = normalizeSlashes(path);
+    for (let relativePath of paths) {
+        if (!relativePath)
+            continue;
+        relativePath = normalizeSlashes(relativePath);
+        if (!path || getRootLength(relativePath) !== 0) {
+            path = relativePath;
+        }
+        else {
+            path = ensureTrailingDirectorySeparator(path) + relativePath;
+        }
+    }
+    return path;
+}
+exports.combinePaths = combinePaths;
+/**
+ * Parse a path into an array containing a root component (at index 0) and zero or more path
+ * components (at indices > 0). The result is normalized.
+ * If the path is relative, the root component is `""`.
+ * If the path is absolute, the root component includes the first path separator (`/`).
+ *
+ * ```ts
+ * getNormalizedPathComponents("to/dir/../file.ext", "/path/") === ["/", "path", "to", "file.ext"]
+ * ```
+ */
+function getNormalizedPathComponents(path, currentDirectory) {
+    return reducePathComponents(getPathComponents(path, currentDirectory));
+}
+exports.getNormalizedPathComponents = getNormalizedPathComponents;
+function normalizePath(path) {
+    path = normalizeSlashes(path);
+    // Most paths don't require normalization
+    if (!relativePathSegmentRegExp.test(path)) {
+        return path;
+    }
+    // Some paths only require cleanup of `/./` or leading `./`
+    const simplified = path.replace(/\/\.\//g, "/").replace(/^\.\//, "");
+    if (simplified !== path) {
+        path = simplified;
+        if (!relativePathSegmentRegExp.test(path)) {
+            return path;
+        }
+    }
+    // Other paths require full normalization
+    const normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
+    return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+}
+exports.normalizePath = normalizePath;
+function removeTrailingDirectorySeparator(path) {
+    if (hasTrailingDirectorySeparator(path)) {
+        return path.substr(0, path.length - 1);
+    }
+    return path;
+}
+exports.removeTrailingDirectorySeparator = removeTrailingDirectorySeparator;
+function ensureTrailingDirectorySeparator(path) {
+    if (!hasTrailingDirectorySeparator(path)) {
+        return path + exports.directorySeparator;
+    }
+    return path;
+}
+//// Path Comparisons
+// check path for these segments: '', '.'. '..'
+const relativePathSegmentRegExp = /(?:\/\/)|(?:^|\/)\.\.?(?:$|\/)/;
+function containsPath(parent, child, currentDirectory, ignoreCase) {
+    if (typeof currentDirectory === "string") {
+        parent = combinePaths(currentDirectory, parent);
+        child = combinePaths(currentDirectory, child);
+    }
+    else if (typeof currentDirectory === "boolean") {
+        ignoreCase = currentDirectory;
+    }
+    if (parent === undefined || child === undefined)
+        return false;
+    if (parent === child)
+        return true;
+    const parentComponents = reducePathComponents(getPathComponents(parent));
+    const childComponents = reducePathComponents(getPathComponents(child));
+    if (childComponents.length < parentComponents.length) {
+        return false;
+    }
+    const componentEqualityComparer = ignoreCase ? core_1.equateStringsCaseInsensitive : core_1.equateStringsCaseSensitive;
+    for (let i = 0; i < parentComponents.length; i++) {
+        const equalityComparer = i === 0 ? core_1.equateStringsCaseInsensitive : componentEqualityComparer;
+        if (!equalityComparer(parentComponents[i], childComponents[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.containsPath = containsPath;
+//# sourceMappingURL=path.js.map

node_modules/@volar/typescript/lib/typescript/types.d.ts

@@ -0,0 +1,130 @@
+export type Path = string & {
+    __pathBrand: any;
+};
+export declare const enum CharacterCodes {
+    nullCharacter = 0,
+    maxAsciiCharacter = 127,
+    lineFeed = 10,
+    carriageReturn = 13,
+    lineSeparator = 8232,
+    paragraphSeparator = 8233,
+    nextLine = 133,
+    space = 32,
+    nonBreakingSpace = 160,
+    enQuad = 8192,
+    emQuad = 8193,
+    enSpace = 8194,
+    emSpace = 8195,
+    threePerEmSpace = 8196,
+    fourPerEmSpace = 8197,
+    sixPerEmSpace = 8198,
+    figureSpace = 8199,
+    punctuationSpace = 8200,
+    thinSpace = 8201,
+    hairSpace = 8202,
+    zeroWidthSpace = 8203,
+    narrowNoBreakSpace = 8239,
+    ideographicSpace = 12288,
+    mathematicalSpace = 8287,
+    ogham = 5760,
+    _ = 95,
+    $ = 36,
+    _0 = 48,
+    _1 = 49,
+    _2 = 50,
+    _3 = 51,
+    _4 = 52,
+    _5 = 53,
+    _6 = 54,
+    _7 = 55,
+    _8 = 56,
+    _9 = 57,
+    a = 97,
+    b = 98,
+    c = 99,
+    d = 100,
+    e = 101,
+    f = 102,
+    g = 103,
+    h = 104,
+    i = 105,
+    j = 106,
+    k = 107,
+    l = 108,
+    m = 109,
+    n = 110,
+    o = 111,
+    p = 112,
+    q = 113,
+    r = 114,
+    s = 115,
+    t = 116,
+    u = 117,
+    v = 118,
+    w = 119,
+    x = 120,
+    y = 121,
+    z = 122,
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    E = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    ampersand = 38,
+    asterisk = 42,
+    at = 64,
+    backslash = 92,
+    backtick = 96,
+    bar = 124,
+    caret = 94,
+    closeBrace = 125,
+    closeBracket = 93,
+    closeParen = 41,
+    colon = 58,
+    comma = 44,
+    dot = 46,
+    doubleQuote = 34,
+    equals = 61,
+    exclamation = 33,
+    greaterThan = 62,
+    hash = 35,
+    lessThan = 60,
+    minus = 45,
+    openBrace = 123,
+    openBracket = 91,
+    openParen = 40,
+    percent = 37,
+    plus = 43,
+    question = 63,
+    semicolon = 59,
+    singleQuote = 39,
+    slash = 47,
+    tilde = 126,
+    backspace = 8,
+    formFeed = 12,
+    byteOrderMark = 65279,
+    tab = 9,
+    verticalTab = 11
+}
+//# sourceMappingURL=types.d.ts.map

node_modules/@volar/typescript/lib/typescript/types.js

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

node_modules/@volar/typescript/lib/typescript/utilities.d.ts

@@ -0,0 +1,8 @@
+interface FileSystemEntries {
+    readonly files: readonly string[];
+    readonly directories: readonly string[];
+}
+/** @param path directory of the tsconfig.json */
+export declare function matchFiles(path: string, extensions: readonly string[] | undefined, excludes: readonly string[] | undefined, includes: readonly string[] | undefined, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getFileSystemEntries: (path: string) => FileSystemEntries, realpath: (path: string) => string): string[];
+export {};
+//# sourceMappingURL=utilities.d.ts.map

node_modules/@volar/typescript/lib/typescript/utilities.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchFiles = void 0;
+const core_1 = require("./core");
+const path_1 = require("./path");
+// KLUDGE: Don't assume one 'node_modules' links to another. More likely a single directory inside the node_modules is the symlink.
+// ALso, don't assume that an `@foo` directory is linked. More likely the contents of that are linked.
+// Reserved characters, forces escaping of any non-word (or digit), non-whitespace character.
+// It may be inefficient (we could just match (/[-[\]{}()*+?.,\\^$|#\s]/g), but this is future
+// proof.
+const reservedCharacterPattern = /[^\w\s\/]/g;
+const wildcardCharCodes = [42 /* CharacterCodes.asterisk */, 63 /* CharacterCodes.question */];
+const commonPackageFolders = ["node_modules", "bower_components", "jspm_packages"];
+const implicitExcludePathRegexPattern = `(?!(${commonPackageFolders.join("|")})(/|$))`;
+const filesMatcher = {
+    /**
+     * Matches any single directory segment unless it is the last segment and a .min.js file
+     * Breakdown:
+     *  [^./]                   # matches everything up to the first . character (excluding directory separators)
+     *  (\\.(?!min\\.js$))?     # matches . characters but not if they are part of the .min.js file extension
+     */
+    singleAsteriskRegexFragment: "([^./]|(\\.(?!min\\.js$))?)*",
+    /**
+     * Regex for the ** wildcard. Matches any number of subdirectories. When used for including
+     * files or directories, does not match subdirectories that start with a . character
+     */
+    doubleAsteriskRegexFragment: `(/${implicitExcludePathRegexPattern}[^/.][^/]*)*?`,
+    replaceWildcardCharacter: match => replaceWildcardCharacter(match, filesMatcher.singleAsteriskRegexFragment)
+};
+const directoriesMatcher = {
+    singleAsteriskRegexFragment: "[^/]*",
+    /**
+     * Regex for the ** wildcard. Matches any number of subdirectories. When used for including
+     * files or directories, does not match subdirectories that start with a . character
+     */
+    doubleAsteriskRegexFragment: `(/${implicitExcludePathRegexPattern}[^/.][^/]*)*?`,
+    replaceWildcardCharacter: match => replaceWildcardCharacter(match, directoriesMatcher.singleAsteriskRegexFragment)
+};
+const excludeMatcher = {
+    singleAsteriskRegexFragment: "[^/]*",
+    doubleAsteriskRegexFragment: "(/.+?)?",
+    replaceWildcardCharacter: match => replaceWildcardCharacter(match, excludeMatcher.singleAsteriskRegexFragment)
+};
+const wildcardMatchers = {
+    files: filesMatcher,
+    directories: directoriesMatcher,
+    exclude: excludeMatcher
+};
+function getRegularExpressionForWildcard(specs, basePath, usage) {
+    const patterns = getRegularExpressionsForWildcards(specs, basePath, usage);
+    if (!patterns || !patterns.length) {
+        return undefined;
+    }
+    const pattern = patterns.map(pattern => `(${pattern})`).join("|");
+    // If excluding, match "foo/bar/baz...", but if including, only allow "foo".
+    const terminator = usage === "exclude" ? "($|/)" : "$";
+    return `^(${pattern})${terminator}`;
+}
+function getRegularExpressionsForWildcards(specs, basePath, usage) {
+    if (specs === undefined || specs.length === 0) {
+        return undefined;
+    }
+    return (0, core_1.flatMap)(specs, spec => spec && getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]));
+}
+/**
+ * An "includes" path "foo" is implicitly a glob "foo/** /*" (without the space) if its last component has no extension,
+ * and does not contain any glob characters itself.
+ */
+function isImplicitGlob(lastPathComponent) {
+    return !/[.*?]/.test(lastPathComponent);
+}
+function getSubPatternFromSpec(spec, basePath, usage, { singleAsteriskRegexFragment, doubleAsteriskRegexFragment, replaceWildcardCharacter }) {
+    let subpattern = "";
+    let hasWrittenComponent = false;
+    const components = (0, path_1.getNormalizedPathComponents)(spec, basePath);
+    const lastComponent = (0, core_1.last)(components);
+    if (usage !== "exclude" && lastComponent === "**") {
+        return undefined;
+    }
+    // getNormalizedPathComponents includes the separator for the root component.
+    // We need to remove to create our regex correctly.
+    components[0] = (0, path_1.removeTrailingDirectorySeparator)(components[0]);
+    if (isImplicitGlob(lastComponent)) {
+        components.push("**", "*");
+    }
+    let optionalCount = 0;
+    for (let component of components) {
+        if (component === "**") {
+            subpattern += doubleAsteriskRegexFragment;
+        }
+        else {
+            if (usage === "directories") {
+                subpattern += "(";
+                optionalCount++;
+            }
+            if (hasWrittenComponent) {
+                subpattern += path_1.directorySeparator;
+            }
+            if (usage !== "exclude") {
+                let componentPattern = "";
+                // The * and ? wildcards should not match directories or files that start with . if they
+                // appear first in a component. Dotted directories and files can be included explicitly
+                // like so: **/.*/.*
+                if (component.charCodeAt(0) === 42 /* CharacterCodes.asterisk */) {
+                    componentPattern += "([^./]" + singleAsteriskRegexFragment + ")?";
+                    component = component.substr(1);
+                }
+                else if (component.charCodeAt(0) === 63 /* CharacterCodes.question */) {
+                    componentPattern += "[^./]";
+                    component = component.substr(1);
+                }
+                componentPattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter);
+                // Patterns should not include subfolders like node_modules unless they are
+                // explicitly included as part of the path.
+                //
+                // As an optimization, if the component pattern is the same as the component,
+                // then there definitely were no wildcard characters and we do not need to
+                // add the exclusion pattern.
+                if (componentPattern !== component) {
+                    subpattern += implicitExcludePathRegexPattern;
+                }
+                subpattern += componentPattern;
+            }
+            else {
+                subpattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter);
+            }
+        }
+        hasWrittenComponent = true;
+    }
+    while (optionalCount > 0) {
+        subpattern += ")?";
+        optionalCount--;
+    }
+    return subpattern;
+}
+function replaceWildcardCharacter(match, singleAsteriskRegexFragment) {
+    return match === "*" ? singleAsteriskRegexFragment : match === "?" ? "[^/]" : "\\" + match;
+}
+/** @param path directory of the tsconfig.json */
+function getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory) {
+    path = (0, path_1.normalizePath)(path);
+    currentDirectory = (0, path_1.normalizePath)(currentDirectory);
+    const absolutePath = (0, path_1.combinePaths)(currentDirectory, path);
+    return {
+        includeFilePatterns: (0, core_1.map)(getRegularExpressionsForWildcards(includes, absolutePath, "files"), pattern => `^${pattern}$`),
+        includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
+        includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
+        excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
+        basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
+    };
+}
+function getRegexFromPattern(pattern, useCaseSensitiveFileNames) {
+    return new RegExp(pattern, useCaseSensitiveFileNames ? "" : "i");
+}
+/** @param path directory of the tsconfig.json */
+function matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath) {
+    path = (0, path_1.normalizePath)(path);
+    currentDirectory = (0, path_1.normalizePath)(currentDirectory);
+    const patterns = getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory);
+    const includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map(pattern => getRegexFromPattern(pattern, useCaseSensitiveFileNames));
+    const includeDirectoryRegex = patterns.includeDirectoryPattern && getRegexFromPattern(patterns.includeDirectoryPattern, useCaseSensitiveFileNames);
+    const excludeRegex = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames);
+    // Associate an array of results with each include regex. This keeps results in order of the "include" order.
+    // If there are no "includes", then just put everything in results[0].
+    const results = includeFileRegexes ? includeFileRegexes.map(() => []) : [[]];
+    const visited = new Map();
+    const toCanonical = (0, core_1.createGetCanonicalFileName)(useCaseSensitiveFileNames);
+    for (const basePath of patterns.basePaths) {
+        visitDirectory(basePath, (0, path_1.combinePaths)(currentDirectory, basePath), depth);
+    }
+    return (0, core_1.flatten)(results);
+    function visitDirectory(path, absolutePath, depth) {
+        const canonicalPath = toCanonical(realpath(absolutePath));
+        if (visited.has(canonicalPath))
+            return;
+        visited.set(canonicalPath, true);
+        const { files, directories } = getFileSystemEntries(path);
+        for (const current of (0, core_1.sort)(files, core_1.compareStringsCaseSensitive)) {
+            const name = (0, path_1.combinePaths)(path, current);
+            const absoluteName = (0, path_1.combinePaths)(absolutePath, current);
+            if (extensions && !(0, path_1.fileExtensionIsOneOf)(name, extensions))
+                continue;
+            if (excludeRegex && excludeRegex.test(absoluteName))
+                continue;
+            if (!includeFileRegexes) {
+                results[0].push(name);
+            }
+            else {
+                const includeIndex = (0, core_1.findIndex)(includeFileRegexes, re => re.test(absoluteName));
+                if (includeIndex !== -1) {
+                    results[includeIndex].push(name);
+                }
+            }
+        }
+        if (depth !== undefined) {
+            depth--;
+            if (depth === 0) {
+                return;
+            }
+        }
+        for (const current of (0, core_1.sort)(directories, core_1.compareStringsCaseSensitive)) {
+            const name = (0, path_1.combinePaths)(path, current);
+            const absoluteName = (0, path_1.combinePaths)(absolutePath, current);
+            if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
+                (!excludeRegex || !excludeRegex.test(absoluteName))) {
+                visitDirectory(name, absoluteName, depth);
+            }
+        }
+    }
+}
+exports.matchFiles = matchFiles;
+/**
+ * Computes the unique non-wildcard base paths amongst the provided include patterns.
+ */
+function getBasePaths(path, includes, useCaseSensitiveFileNames) {
+    // Storage for our results in the form of literal paths (e.g. the paths as written by the user).
+    const basePaths = [path];
+    if (includes) {
+        // Storage for literal base paths amongst the include patterns.
+        const includeBasePaths = [];
+        for (const include of includes) {
+            // We also need to check the relative paths by converting them to absolute and normalizing
+            // in case they escape the base path (e.g "..\somedirectory")
+            const absolute = (0, path_1.isRootedDiskPath)(include) ? include : (0, path_1.normalizePath)((0, path_1.combinePaths)(path, include));
+            // Append the literal and canonical candidate base paths.
+            includeBasePaths.push(getIncludeBasePath(absolute));
+        }
+        // Sort the offsets array using either the literal or canonical path representations.
+        includeBasePaths.sort((0, core_1.getStringComparer)(!useCaseSensitiveFileNames));
+        // Iterate over each include base path and include unique base paths that are not a
+        // subpath of an existing base path
+        for (const includeBasePath of includeBasePaths) {
+            if ((0, core_1.every)(basePaths, basePath => !(0, path_1.containsPath)(basePath, includeBasePath, path, !useCaseSensitiveFileNames))) {
+                basePaths.push(includeBasePath);
+            }
+        }
+    }
+    return basePaths;
+}
+function getIncludeBasePath(absolute) {
+    const wildcardOffset = (0, core_1.indexOfAnyCharCode)(absolute, wildcardCharCodes);
+    if (wildcardOffset < 0) {
+        // No "*" or "?" in the path
+        return !(0, path_1.hasExtension)(absolute)
+            ? absolute
+            : (0, path_1.removeTrailingDirectorySeparator)((0, path_1.getDirectoryPath)(absolute));
+    }
+    return absolute.substring(0, absolute.lastIndexOf(path_1.directorySeparator, wildcardOffset));
+}
+//# sourceMappingURL=utilities.js.map

node_modules/@volar/typescript/package.json

@@ -0,0 +1,23 @@
+{
+	"name": "@volar/typescript",
+	"version": "1.11.1",
+	"license": "MIT",
+	"files": [
+		"**/*.js",
+		"**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/volar.js.git",
+		"directory": "packages/typescript"
+	},
+	"dependencies": {
+		"@volar/language-core": "1.11.1",
+		"path-browserify": "^1.0.1"
+	},
+	"devDependencies": {
+		"@types/path-browserify": "latest",
+		"@volar/language-service": "1.11.1"
+	},
+	"gitHead": "188f49ee79bd2ea8e8fc32b80003c85f79868f9d"
+}