Revamping to matrix style

node_modules/@volar/kit/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/kit/README.md

@@ -0,0 +1,98 @@
+# Kit
+
+## Example: Use FileWatcher
+
+```ts
+import * as fs from 'fs';
+import * as path from 'path';
+import { watch } from 'chokidar';
+import * as kit from '@volar/kit';
+
+const tsconfig = getTsconfig();
+const project = kit.createProject(tsconfig, [{ extension: 'foo', isMixedContent: true, scriptKind: 7 }]);
+const config: kit.Config = {
+    languages: {
+        // ...
+    },
+    services: {
+        // ...
+    },
+};
+const linter = kit.createLinter(config, project.languageServiceHost);
+
+let req = 0;
+
+update();
+
+createWatcher(path.dirname(tsconfig), ['ts', 'js', 'foo'])
+    .on('add', (fileName) => {
+        project.fileCreated(fileName);
+        update();
+    })
+    .on('unlink', (fileName) => {
+        project.fileDeleted(fileName);
+        update();
+    })
+    .on('change', (fileName) => {
+        project.fileUpdated(fileName);
+        update();
+    });
+
+function createWatcher(rootPath: string, extension: string[]) {
+    return watch(`${rootPath}/**/*.{${extension.join(',')}}`, {
+        ignored: (path) => path.includes('node_modules'),
+        ignoreInitial: true
+    });
+}
+
+async function update() {
+
+    const currentReq = ++req;
+    const isCanceled = () => currentReq !== req;
+    await new Promise(resolve => setTimeout(resolve, 100));
+    if (isCanceled()) return;
+
+    process.stdout.write('\x1Bc'); // clear console
+
+    let hasError = false;
+    for (const fileName of project.languageServiceHost.getScriptFileNames()) {
+        const errors = await linter.check(fileName);
+        if (isCanceled()) return;
+        if (errors.length) {
+            linter.logErrors(fileName, errors);
+            hasError = true;
+        }
+    }
+    if (!hasError) {
+        console.log('No errors');
+    }
+}
+
+function getTsconfig() {
+
+    let tsconfig = path.resolve(process.cwd(), './tsconfig.json');
+
+    const tsconfigIndex = process.argv.indexOf('--tsconfig');
+    if (tsconfigIndex >= 0) {
+        tsconfig = path.resolve(process.cwd(), process.argv[tsconfigIndex + 1]);
+    }
+
+    if (!fs.existsSync(tsconfig)) {
+        throw `tsconfig.json not found: ${tsconfig}`;
+    }
+
+    return tsconfig;
+}
+```
+
+## Create Project without tsconfig.json
+
+```ts
+const rootPath = process.cwd();
+const fileNames = [
+	path.resolve(rootPath, './src/a.ts'),
+	path.resolve(rootPath, './src/b.js'),
+	path.resolve(rootPath, './src/c.foo'),
+];
+const project = kit.createInferredProject(rootPath, fileNames);
+```

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

@@ -0,0 +1,3 @@
+export * from '@volar/language-service';
+export * from './lib/createFormatter';
+export * from './lib/createChecker';

node_modules/@volar/kit/index.js

@@ -0,0 +1,20 @@
+"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("@volar/language-service"), exports);
+__exportStar(require("./lib/createFormatter"), exports);
+__exportStar(require("./lib/createChecker"), exports);
+//# sourceMappingURL=index.js.map

node_modules/@volar/kit/lib/createChecker.d.ts

@@ -0,0 +1,31 @@
+import { Diagnostic, Language, LanguagePlugin, LanguageServicePlugin, ProjectContext } from '@volar/language-service';
+import * as ts from 'typescript';
+import { URI } from 'vscode-uri';
+export declare function createTypeScriptChecker(languagePlugins: LanguagePlugin<URI>[], languageServicePlugins: LanguageServicePlugin[], tsconfig: string, includeProjectReference?: boolean, setup?: (options: {
+    language: Language;
+    project: ProjectContext;
+}) => void): {
+    check: (fileName: string) => Promise<Diagnostic[]>;
+    fixErrors: (fileName: string, diagnostics: Diagnostic[], only: string[] | undefined, writeFile: (fileName: string, newText: string) => Promise<void>) => Promise<void>;
+    printErrors: (fileName: string, diagnostics: Diagnostic[], rootPath?: string) => string;
+    getRootFileNames: () => string[];
+    language: Language<URI>;
+    settings: {};
+    fileCreated(fileName: string): void;
+    fileUpdated(fileName: string): void;
+    fileDeleted(fileName: string): void;
+};
+export declare function createTypeScriptInferredChecker(languagePlugins: LanguagePlugin<URI>[], languageServicePlugins: LanguageServicePlugin[], getScriptFileNames: () => string[], compilerOptions?: ts.CompilerOptions, setup?: (options: {
+    language: Language;
+    project: ProjectContext;
+}) => void): {
+    check: (fileName: string) => Promise<Diagnostic[]>;
+    fixErrors: (fileName: string, diagnostics: Diagnostic[], only: string[] | undefined, writeFile: (fileName: string, newText: string) => Promise<void>) => Promise<void>;
+    printErrors: (fileName: string, diagnostics: Diagnostic[], rootPath?: string) => string;
+    getRootFileNames: () => string[];
+    language: Language<URI>;
+    settings: {};
+    fileCreated(fileName: string): void;
+    fileUpdated(fileName: string): void;
+    fileDeleted(fileName: string): void;
+};

node_modules/@volar/kit/lib/createChecker.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypeScriptChecker = createTypeScriptChecker;
+exports.createTypeScriptInferredChecker = createTypeScriptInferredChecker;
+const language_service_1 = require("@volar/language-service");
+const typescript_1 = require("@volar/typescript");
+const path = require("typesafe-path/posix");
+const ts = require("typescript");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const vscode_uri_1 = require("vscode-uri");
+const createServiceEnvironment_1 = require("./createServiceEnvironment");
+const utils_1 = require("./utils");
+function createTypeScriptChecker(languagePlugins, languageServicePlugins, tsconfig, includeProjectReference = false, setup) {
+    const tsconfigPath = (0, utils_1.asPosix)(tsconfig);
+    return createTypeScriptCheckerWorker(languagePlugins, languageServicePlugins, tsconfigPath, () => {
+        return ts.parseJsonSourceFileConfigFileContent(ts.readJsonConfigFile(tsconfigPath, ts.sys.readFile), ts.sys, path.dirname(tsconfigPath), undefined, tsconfigPath, undefined, languagePlugins.map(plugin => plugin.typescript?.extraFileExtensions ?? []).flat());
+    }, includeProjectReference, setup);
+}
+function createTypeScriptInferredChecker(languagePlugins, languageServicePlugins, getScriptFileNames, compilerOptions = utils_1.defaultCompilerOptions, setup) {
+    return createTypeScriptCheckerWorker(languagePlugins, languageServicePlugins, undefined, () => {
+        return {
+            options: compilerOptions,
+            fileNames: getScriptFileNames(),
+            errors: [],
+        };
+    }, false, setup);
+}
+const fsFileSnapshots = (0, language_service_1.createUriMap)();
+function createTypeScriptCheckerWorker(languagePlugins, languageServicePlugins, configFileName, getCommandLine, includeProjectReference, setup) {
+    let settings = {};
+    const didChangeWatchedFilesCallbacks = new Set();
+    const env = (0, createServiceEnvironment_1.createServiceEnvironment)(() => settings);
+    env.onDidChangeWatchedFiles = cb => {
+        didChangeWatchedFilesCallbacks.add(cb);
+        return {
+            dispose: () => {
+                didChangeWatchedFilesCallbacks.delete(cb);
+            },
+        };
+    };
+    const language = (0, language_service_1.createLanguage)([
+        ...languagePlugins,
+        { getLanguageId: uri => (0, typescript_1.resolveFileLanguageId)(uri.path) },
+    ], (0, language_service_1.createUriMap)(ts.sys.useCaseSensitiveFileNames), (uri, includeFsFiles) => {
+        if (!includeFsFiles) {
+            return;
+        }
+        const cache = fsFileSnapshots.get(uri);
+        const fileName = (0, utils_1.asFileName)(uri);
+        const modifiedTime = ts.sys.getModifiedTime?.(fileName)?.valueOf();
+        if (!cache || cache[0] !== modifiedTime) {
+            if (ts.sys.fileExists(fileName)) {
+                const text = ts.sys.readFile(fileName);
+                const snapshot = text !== undefined ? ts.ScriptSnapshot.fromString(text) : undefined;
+                fsFileSnapshots.set(uri, [modifiedTime, snapshot]);
+            }
+            else {
+                fsFileSnapshots.set(uri, [modifiedTime, undefined]);
+            }
+        }
+        const snapshot = fsFileSnapshots.get(uri)?.[1];
+        if (snapshot) {
+            language.scripts.set(uri, snapshot);
+        }
+        else {
+            language.scripts.delete(uri);
+        }
+    });
+    const [projectHost, languageService] = createTypeScriptCheckerLanguageService(env, language, languageServicePlugins, configFileName, getCommandLine, setup);
+    const projectReferenceLanguageServices = new Map();
+    if (includeProjectReference) {
+        const tsconfigs = new Set();
+        const tsLs = languageService.context.inject('typescript/languageService');
+        const projectReferences = tsLs.getProgram()?.getResolvedProjectReferences();
+        if (configFileName) {
+            tsconfigs.add((0, utils_1.asPosix)(configFileName));
+        }
+        projectReferences?.forEach(visit);
+        function visit(ref) {
+            if (ref && !tsconfigs.has(ref.sourceFile.fileName)) {
+                tsconfigs.add(ref.sourceFile.fileName);
+                const projectReferenceLanguageService = createTypeScriptCheckerLanguageService(env, language, languageServicePlugins, ref.sourceFile.fileName, () => ref.commandLine, setup);
+                projectReferenceLanguageServices.set(ref.sourceFile.fileName, projectReferenceLanguageService);
+                ref.references?.forEach(visit);
+            }
+        }
+    }
+    return {
+        // apis
+        check,
+        fixErrors,
+        printErrors,
+        getRootFileNames: () => {
+            const fileNames = projectHost.getScriptFileNames();
+            for (const [projectHost] of projectReferenceLanguageServices.values()) {
+                fileNames.push(...projectHost.getScriptFileNames());
+            }
+            return [...new Set(fileNames)];
+        },
+        language,
+        // settings
+        get settings() {
+            return settings;
+        },
+        set settings(v) {
+            settings = v;
+        },
+        // file events
+        fileCreated(fileName) {
+            fileEvent(fileName, 1);
+        },
+        fileUpdated(fileName) {
+            fileEvent(fileName, 2);
+        },
+        fileDeleted(fileName) {
+            fileEvent(fileName, 3);
+        },
+    };
+    function fileEvent(fileName, type) {
+        fileName = (0, utils_1.asPosix)(fileName);
+        for (const cb of didChangeWatchedFilesCallbacks) {
+            cb({ changes: [{ uri: (0, utils_1.asUri)(fileName).toString(), type }] });
+        }
+    }
+    function check(fileName) {
+        fileName = (0, utils_1.asPosix)(fileName);
+        const uri = (0, utils_1.asUri)(fileName);
+        const languageService = getLanguageServiceForFile(fileName);
+        return languageService.getDiagnostics(uri);
+    }
+    async function fixErrors(fileName, diagnostics, only, writeFile) {
+        fileName = (0, utils_1.asPosix)(fileName);
+        const uri = (0, utils_1.asUri)(fileName);
+        const languageService = getLanguageServiceForFile(fileName);
+        const sourceScript = languageService.context.language.scripts.get(uri);
+        if (sourceScript) {
+            const document = languageService.context.documents.get(uri, sourceScript.languageId, sourceScript.snapshot);
+            const range = { start: document.positionAt(0), end: document.positionAt(document.getText().length) };
+            const codeActions = await languageService.getCodeActions(uri, range, { diagnostics, only, triggerKind: 1 });
+            if (codeActions) {
+                for (let i = 0; i < codeActions.length; i++) {
+                    codeActions[i] = await languageService.resolveCodeAction(codeActions[i]);
+                }
+                const edits = codeActions.map(codeAction => codeAction.edit).filter((edit) => !!edit);
+                if (edits.length) {
+                    const rootEdit = edits[0];
+                    (0, language_service_1.mergeWorkspaceEdits)(rootEdit, ...edits.slice(1));
+                    for (const uri in rootEdit.changes ?? {}) {
+                        const edits = rootEdit.changes[uri];
+                        if (edits.length) {
+                            const parsedUri = vscode_uri_1.URI.parse(uri);
+                            const editFile = languageService.context.language.scripts.get(parsedUri);
+                            if (editFile) {
+                                const editDocument = languageService.context.documents.get(parsedUri, editFile.languageId, editFile.snapshot);
+                                const newString = vscode_languageserver_textdocument_1.TextDocument.applyEdits(editDocument, edits);
+                                await writeFile((0, utils_1.asFileName)(parsedUri), newString);
+                            }
+                        }
+                    }
+                    for (const change of rootEdit.documentChanges ?? []) {
+                        if ('textDocument' in change) {
+                            const changeUri = vscode_uri_1.URI.parse(change.textDocument.uri);
+                            const editFile = languageService.context.language.scripts.get(changeUri);
+                            if (editFile) {
+                                const editDocument = languageService.context.documents.get(changeUri, editFile.languageId, editFile.snapshot);
+                                const newString = vscode_languageserver_textdocument_1.TextDocument.applyEdits(editDocument, change.edits);
+                                await writeFile((0, utils_1.asFileName)(changeUri), newString);
+                            }
+                        }
+                        // TODO: CreateFile | RenameFile | DeleteFile
+                    }
+                }
+            }
+        }
+    }
+    function printErrors(fileName, diagnostics, rootPath = process.cwd()) {
+        let text = formatErrors(fileName, diagnostics, rootPath);
+        for (const diagnostic of diagnostics) {
+            text = text.replace(`TS${diagnostic.code}`, (diagnostic.source ?? '') + (diagnostic.code ? `(${diagnostic.code})` : ''));
+        }
+        return text;
+    }
+    function formatErrors(fileName, diagnostics, rootPath) {
+        fileName = (0, utils_1.asPosix)(fileName);
+        const uri = (0, utils_1.asUri)(fileName);
+        const languageService = getLanguageServiceForFile(fileName);
+        const sourceScript = languageService.context.language.scripts.get(uri);
+        const document = languageService.context.documents.get(uri, sourceScript.languageId, sourceScript.snapshot);
+        const errors = diagnostics.map(diagnostic => ({
+            category: diagnostic.severity === 1 ? ts.DiagnosticCategory.Error : ts.DiagnosticCategory.Warning,
+            code: diagnostic.code,
+            file: ts.createSourceFile(fileName, document.getText(), ts.ScriptTarget.JSON),
+            start: document.offsetAt(diagnostic.range.start),
+            length: document.offsetAt(diagnostic.range.end) - document.offsetAt(diagnostic.range.start),
+            messageText: diagnostic.message,
+        }));
+        const text = ts.formatDiagnosticsWithColorAndContext(errors, {
+            getCurrentDirectory: () => rootPath,
+            getCanonicalFileName: fileName => ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
+            getNewLine: () => ts.sys.newLine,
+        });
+        return text;
+    }
+    function getLanguageServiceForFile(fileName) {
+        if (!includeProjectReference) {
+            return languageService;
+        }
+        fileName = (0, utils_1.asPosix)(fileName);
+        for (const [_1, languageService] of projectReferenceLanguageServices.values()) {
+            const tsLs = languageService.context.inject('typescript/languageService');
+            if (tsLs.getProgram()?.getSourceFile(fileName)) {
+                return languageService;
+            }
+        }
+        return languageService;
+    }
+}
+function createTypeScriptCheckerLanguageService(env, language, languageServicePlugins, configFileName, getCommandLine, setup) {
+    let commandLine = getCommandLine();
+    let projectVersion = 0;
+    let shouldCheckRootFiles = false;
+    const resolvedFileNameByCommandLine = new WeakMap();
+    const projectHost = {
+        getCurrentDirectory: () => env.workspaceFolders.length
+            ? (0, utils_1.asFileName)(env.workspaceFolders[0])
+            : process.cwd(),
+        getCompilationSettings: () => {
+            return commandLine.options;
+        },
+        getProjectReferences: () => {
+            return commandLine.projectReferences;
+        },
+        getProjectVersion: () => {
+            checkRootFilesUpdate();
+            return projectVersion.toString();
+        },
+        getScriptFileNames: () => {
+            checkRootFilesUpdate();
+            let fileNames = resolvedFileNameByCommandLine.get(commandLine);
+            if (!fileNames) {
+                fileNames = commandLine.fileNames.map(utils_1.asPosix);
+                resolvedFileNameByCommandLine.set(commandLine, fileNames);
+            }
+            return fileNames;
+        },
+    };
+    const project = {
+        typescript: {
+            configFileName,
+            sys: ts.sys,
+            uriConverter: {
+                asFileName: utils_1.asFileName,
+                asUri: utils_1.asUri,
+            },
+            ...(0, typescript_1.createLanguageServiceHost)(ts, ts.sys, language, utils_1.asUri, projectHost),
+        },
+    };
+    setup?.({ language, project });
+    const languageService = (0, language_service_1.createLanguageService)(language, languageServicePlugins, env, project);
+    env.onDidChangeWatchedFiles?.(({ changes }) => {
+        const tsLs = languageService.context.inject('typescript/languageService');
+        const program = tsLs.getProgram();
+        for (const change of changes) {
+            const changeUri = vscode_uri_1.URI.parse(change.uri);
+            const fileName = (0, utils_1.asFileName)(changeUri);
+            if (change.type === 2) {
+                if (program?.getSourceFile(fileName)) {
+                    projectVersion++;
+                }
+            }
+            else if (change.type === 3) {
+                if (program?.getSourceFile(fileName)) {
+                    projectVersion++;
+                    shouldCheckRootFiles = true;
+                    break;
+                }
+            }
+            else if (change.type === 1) {
+                shouldCheckRootFiles = true;
+                break;
+            }
+        }
+    });
+    return [projectHost, languageService];
+    function checkRootFilesUpdate() {
+        if (!shouldCheckRootFiles) {
+            return;
+        }
+        shouldCheckRootFiles = false;
+        const newCommandLine = getCommandLine();
+        if (!arrayItemsEqual(newCommandLine.fileNames, commandLine.fileNames)) {
+            commandLine.fileNames = newCommandLine.fileNames;
+            projectVersion++;
+        }
+    }
+}
+function arrayItemsEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    const set = new Set(a);
+    for (const file of b) {
+        if (!set.has(file)) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=createChecker.js.map

node_modules/@volar/kit/lib/createFormatter.d.ts

@@ -0,0 +1,7 @@
+import { FormattingOptions, LanguagePlugin, LanguageServicePlugin } from '@volar/language-service';
+import { URI } from 'vscode-uri';
+export declare function createFormatter(languages: LanguagePlugin<URI>[], services: LanguageServicePlugin[]): {
+    env: import("@volar/language-service").LanguageServiceEnvironment;
+    format: (content: string, languageId: string, options: FormattingOptions) => Promise<string>;
+    settings: {};
+};

node_modules/@volar/kit/lib/createFormatter.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFormatter = createFormatter;
+const language_service_1 = require("@volar/language-service");
+const ts = require("typescript");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const vscode_uri_1 = require("vscode-uri");
+const createServiceEnvironment_1 = require("./createServiceEnvironment");
+function createFormatter(languages, services) {
+    let settings = {};
+    const fakeUri = vscode_uri_1.URI.parse('file:///dummy.txt');
+    const env = (0, createServiceEnvironment_1.createServiceEnvironment)(() => settings);
+    const language = (0, language_service_1.createLanguage)(languages, (0, language_service_1.createUriMap)(false), () => { });
+    const languageService = (0, language_service_1.createLanguageService)(language, services, env, {});
+    return {
+        env,
+        format,
+        get settings() {
+            return settings;
+        },
+        set settings(v) {
+            settings = v;
+        },
+    };
+    async function format(content, languageId, options) {
+        const snapshot = ts.ScriptSnapshot.fromString(content);
+        language.scripts.set(fakeUri, snapshot, languageId);
+        const document = languageService.context.documents.get(fakeUri, languageId, snapshot);
+        const edits = await languageService.getDocumentFormattingEdits(fakeUri, options, undefined, undefined);
+        if (edits?.length) {
+            const newString = vscode_languageserver_textdocument_1.TextDocument.applyEdits(document, edits);
+            return newString;
+        }
+        return content;
+    }
+}
+//# sourceMappingURL=createFormatter.js.map

node_modules/@volar/kit/lib/createServiceEnvironment.d.ts

@@ -0,0 +1,2 @@
+import { LanguageServiceEnvironment } from '@volar/language-service';
+export declare function createServiceEnvironment(getSettings: () => any): LanguageServiceEnvironment;

node_modules/@volar/kit/lib/createServiceEnvironment.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServiceEnvironment = createServiceEnvironment;
+const language_service_1 = require("@volar/language-service");
+const fs = require("fs");
+const vscode_uri_1 = require("vscode-uri");
+function createServiceEnvironment(getSettings) {
+    return {
+        workspaceFolders: [vscode_uri_1.URI.file(process.cwd())],
+        getConfiguration(section) {
+            const settings = getSettings();
+            if (section in settings) {
+                return settings[section];
+            }
+            let result;
+            for (const settingKey in settings) {
+                if (settingKey.startsWith(`${section}.`)) {
+                    const value = settings[settingKey];
+                    const props = settingKey.substring(section.length + 1).split('.');
+                    result ??= {};
+                    let current = result;
+                    while (props.length > 1) {
+                        const prop = props.shift();
+                        if (typeof current[prop] !== 'object') {
+                            current[prop] = {};
+                        }
+                        current = current[prop];
+                    }
+                    current[props.shift()] = value;
+                }
+            }
+            return result;
+        },
+        fs: nodeFs,
+        console,
+    };
+}
+const nodeFs = {
+    stat(uri) {
+        if (uri.scheme === 'file') {
+            try {
+                const stats = fs.statSync(uri.fsPath, { throwIfNoEntry: false });
+                if (stats) {
+                    return {
+                        type: stats.isFile() ? language_service_1.FileType.File
+                            : stats.isDirectory() ? language_service_1.FileType.Directory
+                                : stats.isSymbolicLink() ? language_service_1.FileType.SymbolicLink
+                                    : language_service_1.FileType.Unknown,
+                        ctime: stats.ctimeMs,
+                        mtime: stats.mtimeMs,
+                        size: stats.size,
+                    };
+                }
+            }
+            catch {
+                return undefined;
+            }
+        }
+    },
+    readFile(uri, encoding) {
+        if (uri.scheme === 'file') {
+            try {
+                return fs.readFileSync(uri.fsPath, { encoding: encoding ?? 'utf-8' });
+            }
+            catch {
+                return undefined;
+            }
+        }
+    },
+    readDirectory(uri) {
+        if (uri.scheme === 'file') {
+            try {
+                const files = fs.readdirSync(uri.fsPath, { withFileTypes: true });
+                return files.map(file => {
+                    return [file.name, file.isFile() ? language_service_1.FileType.File
+                            : file.isDirectory() ? language_service_1.FileType.Directory
+                                : file.isSymbolicLink() ? language_service_1.FileType.SymbolicLink
+                                    : language_service_1.FileType.Unknown];
+                });
+            }
+            catch {
+                return [];
+            }
+        }
+        return [];
+    },
+};
+//# sourceMappingURL=createServiceEnvironment.js.map

node_modules/@volar/kit/lib/utils.d.ts

@@ -0,0 +1,7 @@
+import type * as path from 'typesafe-path/posix';
+import { URI } from 'vscode-uri';
+import type * as ts from 'typescript';
+export declare const defaultCompilerOptions: ts.CompilerOptions;
+export declare function asPosix(path: string): path.PosixPath;
+export declare const asFileName: (uri: URI) => string;
+export declare const asUri: (fileName: string) => URI;

node_modules/@volar/kit/lib/utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asUri = exports.asFileName = exports.defaultCompilerOptions = void 0;
+exports.asPosix = asPosix;
+const vscode_uri_1 = require("vscode-uri");
+exports.defaultCompilerOptions = {
+    allowJs: true,
+    allowSyntheticDefaultImports: true,
+    allowNonTsExtensions: true,
+    resolveJsonModule: true,
+    jsx: 1,
+};
+function asPosix(path) {
+    return path.replace(/\\/g, '/');
+}
+const asFileName = (uri) => uri.fsPath.replace(/\\/g, '/');
+exports.asFileName = asFileName;
+const asUri = (fileName) => vscode_uri_1.URI.file(fileName);
+exports.asUri = asUri;
+//# sourceMappingURL=utils.js.map

node_modules/@volar/kit/package.json

@@ -0,0 +1,28 @@
+{
+	"name": "@volar/kit",
+	"version": "2.4.12",
+	"license": "MIT",
+	"files": [
+		"**/*.js",
+		"**/*.d.ts"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/volarjs/volar.js.git",
+		"directory": "packages/kit"
+	},
+	"dependencies": {
+		"@volar/language-service": "2.4.12",
+		"@volar/typescript": "2.4.12",
+		"typesafe-path": "^0.2.2",
+		"vscode-languageserver-textdocument": "^1.0.11",
+		"vscode-uri": "^3.0.8"
+	},
+	"devDependencies": {
+		"@types/node": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "*"
+	},
+	"gitHead": "17b9b8a1f522afd1aad1e598d2fd935680d8a8d7"
+}