@spyglassmc/core 0.1.0

package/lib/service/Service.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+const events_1 = __importDefault(require("events"));
+const node_1 = require("../node");
+const processor_1 = require("../processor");
+const source_1 = require("../source");
+const symbol_1 = require("../symbol");
+const Context_1 = require("./Context");
+const Downloader_1 = require("./Downloader");
+const FileService_1 = require("./FileService");
+const Hover_1 = require("./Hover");
+const Logger_1 = require("./Logger");
+const Profiler_1 = require("./Profiler");
+const Project_1 = require("./Project");
+const SymbolLocations_1 = require("./SymbolLocations");
+/* istanbul ignore next */
+class Service extends events_1.default {
+    constructor({ cacheRoot, downloader, fs = FileService_1.FileService.create(), initializers = [], isDebugging = false, logger = Logger_1.Logger.create(), profilers = Profiler_1.ProfilerFactory.noop(), projectPath, }) {
+        super();
+        this.downloader = (downloader ?? (downloader = new Downloader_1.Downloader(cacheRoot, logger)));
+        this.fs = fs;
+        this.isDebugging = isDebugging;
+        this.logger = logger;
+        this.profilers = profilers;
+        this.project = new Project_1.Project({ cacheRoot, downloader, fs, initializers, logger, profilers, projectPath });
+    }
+    debug(message) {
+        if (this.isDebugging) {
+            this.logger.info(`[DEBUG] ${message}`);
+        }
+    }
+    colorize(node, doc, range) {
+        try {
+            this.debug(`Colorizing '${doc.uri}' # ${doc.version}`);
+            const colorizer = this.project.meta.getColorizer(node.type);
+            return colorizer(node, Context_1.ColorizerContext.create(this.project, { doc, range }));
+        }
+        catch (e) {
+            this.logger.error(`[Service] [colorize] Failed for “${doc.uri}” #${doc.version}`, e);
+        }
+        return [];
+    }
+    getColorInfo(node, doc) {
+        try {
+            this.debug(`Getting color info for '${doc.uri}' # ${doc.version}`);
+            const ans = [];
+            (0, processor_1.traversePreOrder)(node, _ => true, node => node.color, node => ans.push({
+                color: Array.isArray(node.color) ? node.color : node.color.value,
+                range: Array.isArray(node.color) ? node.range : (node.color.range ?? node.range),
+            }));
+            return ans;
+        }
+        catch (e) {
+            this.logger.error(`[Service] [getColorInfo] Failed for “${doc.uri}” #${doc.version}`, e);
+        }
+        return [];
+    }
+    getColorPresentation(file, doc, range, color) {
+        try {
+            this.debug(`Getting color presentation for '${doc.uri}' # ${doc.version} @ ${source_1.Range.toString(range)}`);
+            let node = node_1.AstNode.findDeepestChild({ node: file, needle: range.start });
+            while (node) {
+                const nodeColor = node.color;
+                if (nodeColor && !Array.isArray(nodeColor)) {
+                    const colorRange = nodeColor.range ?? node.range;
+                    return nodeColor.format.map(format => processor_1.ColorPresentation.fromColorFormat(format, color, colorRange));
+                }
+                node = node.parent;
+            }
+        }
+        catch (e) {
+            this.logger.error(`[Service] [getColorPresentation] Failed for “${doc.uri}” #${doc.version}`, e);
+        }
+        return [];
+    }
+    complete(node, doc, offset, triggerCharacter) {
+        try {
+            this.debug(`Getting completion for '${doc.uri}' # ${doc.version} @ ${offset}`);
+            const shouldComplete = this.project.meta.shouldComplete(doc.languageId, triggerCharacter);
+            if (shouldComplete) {
+                return processor_1.completer.file(node, Context_1.CompleterContext.create(this.project, { doc, offset, triggerCharacter }));
+            }
+        }
+        catch (e) {
+            this.logger.error(`[Service] [complete] Failed for “${doc.uri}” #${doc.version}`, e);
+        }
+        return [];
+    }
+    dataHackPubify(initialism) {
+        const Secrets = [
+            // data hack pub
+            // —— Skylinerw, 2020 https://discord.com/channels/154777837382008833/154777837382008833/736313565291741355
+            ['ata', 'ack', 'ub', 'elper', 'lus'],
+            // Dah Huh Pew Helpa Plush
+            // —— DoubleFelix, 2021 https://discord.com/channels/154777837382008833/154777837382008833/842070090828087308
+            ['ah', 'uh', 'ew', 'elpa', 'lush'],
+        ];
+        const secrets = Secrets[Math.floor(Math.random() * Secrets.length)];
+        // Punctuation should not be treated differently from any other characters, per example:
+        // Hata &ack Sub
+        // ——  Skylinerw, 2022 https://discord.com/channels/154777837382008833/734106483104415856/955521761351454741
+        return [...initialism]
+            .map((c, i) => `${c.toUpperCase()}${secrets[i % secrets.length]}`)
+            .join(' ');
+    }
+    getHover(file, doc, offset) {
+        try {
+            this.debug(`Getting hover for '${doc.uri}' # ${doc.version} @ ${offset}`);
+            let node = node_1.AstNode.findDeepestChild({ node: file, needle: offset });
+            while (node) {
+                const symbol = this.project.symbols.resolveAlias(node.symbol);
+                if (symbol) {
+                    const hover = `\`\`\`typescript\n(${symbol.category}${symbol.subcategory ? `/${symbol.subcategory}` : ''}) ${symbol.identifier}\n\`\`\`` + (symbol.desc ? `\n******\n${symbol.desc}` : '');
+                    return Hover_1.Hover.create(node.range, hover);
+                }
+                if (node.hover) {
+                    return Hover_1.Hover.create(node.range, node.hover);
+                }
+                node = node.parent;
+            }
+        }
+        catch (e) {
+            this.logger.error(`[Service] [getHover] Failed for “${doc.uri}” #${doc.version}`, e);
+        }
+        return undefined;
+    }
+    getInlayHints(node, doc, range) {
+        try {
+            // TODO: `range` argument is not used.
+            this.debug(`Getting inlay hints for '${doc.uri}' # ${doc.version}`);
+            const ans = [];
+            const ctx = Context_1.ProcessorContext.create(this.project, { doc });
+            for (const provider of this.project.meta.inlayHintProviders) {
+                ans.push(...provider(node, ctx));
+            }
+            return ans;
+        }
+        catch (e) {
+            this.logger.error(`[Service] [getInlayHints] Failed for “${doc.uri}” #${doc.version}`, e);
+        }
+        return [];
+    }
+    getSignatureHelp(node, doc, offset) {
+        try {
+            this.debug(`Getting signature help for '${doc.uri}' # ${doc.version} @ ${offset}`);
+            const ctx = Context_1.SignatureHelpProviderContext.create(this.project, { doc, offset });
+            for (const provider of this.project.meta.signatureHelpProviders) {
+                const result = provider(node, ctx);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        catch (e) {
+            this.logger.error(`[Service] [getSignatureHelp] Failed for “${doc.uri}” #${doc.version}`, e);
+        }
+        return undefined;
+    }
+    /**
+     * @param searchedUsages Type of symbol usages that should be included in the result. Defaults to all usages.
+     * @param currentFileOnly Whether only symbol locations in the current file should be returned.
+     *
+     * @returns Symbol locations of the selected symbol at `offset`, or `undefined` if there's no symbol at `offset`.
+     */
+    getSymbolLocations(file, doc, offset, searchedUsages = symbol_1.SymbolUsageTypes, currentFileOnly = false) {
+        try {
+            this.debug(`Getting symbol locations of usage '${searchedUsages.join(',')}' for '${doc.uri}' # ${doc.version} @ ${offset} with currentFileOnly=${currentFileOnly}`);
+            let node = node_1.AstNode.findDeepestChild({ node: file, needle: offset });
+            while (node) {
+                const symbol = this.project.symbols.resolveAlias(node.symbol);
+                if (symbol) {
+                    const locations = [];
+                    for (const usage of searchedUsages) {
+                        let locs = symbol[usage] ?? [];
+                        if (currentFileOnly) {
+                            locs = locs.filter(l => l.uri === doc.uri);
+                        }
+                        locations.push(...locs);
+                    }
+                    return SymbolLocations_1.SymbolLocations.create(node.range, locations.length ? locations : undefined);
+                }
+                node = node.parent;
+            }
+        }
+        catch (e) {
+            this.logger.error(`[Service] [getSymbolLocations] Failed for “${doc.uri}” #${doc.version}`, e);
+        }
+        return undefined;
+    }
+    format(node, doc, tabSize, insertSpaces) {
+        try {
+            this.debug(`Formatting '${doc.uri}' # ${doc.version}`);
+            const formatter = this.project.meta.getFormatter(node.type);
+            return formatter(node, Context_1.FormatterContext.create(this.project, { doc, tabSize, insertSpaces }));
+        }
+        catch (e) {
+            this.logger.error(`[Service] [format] Failed for “${doc.uri}” #${doc.version}`, e);
+            throw e;
+        }
+    }
+}
+exports.Service = Service;
+//# sourceMappingURL=Service.js.map

package/lib/service/SymbolLocations.d.ts

@@ -0,0 +1,17 @@
+import type { RangeLike } from '../source';
+import { Range } from '../source';
+import type { SymbolLocation } from '../symbol';
+export interface SymbolLocations {
+    /**
+     * The range of the currently selected symbol.
+     */
+    range: Range;
+    /**
+     * All locations of the symbol for the specific usage, or `undefined` if this symbol doesn't have the said usage.
+     */
+    locations: SymbolLocation[] | undefined;
+}
+export declare namespace SymbolLocations {
+    function create(range: RangeLike, locations: SymbolLocation[] | undefined): SymbolLocations;
+}
+//# sourceMappingURL=SymbolLocations.d.ts.map

package/lib/service/SymbolLocations.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolLocations = void 0;
+const source_1 = require("../source");
+var SymbolLocations;
+(function (SymbolLocations) {
+    /* istanbul ignore next */
+    function create(range, locations) {
+        return {
+            range: source_1.Range.get(range),
+            locations,
+        };
+    }
+    SymbolLocations.create = create;
+})(SymbolLocations = exports.SymbolLocations || (exports.SymbolLocations = {}));
+//# sourceMappingURL=SymbolLocations.js.map

package/lib/service/SymbolRegistrar.d.ts

@@ -0,0 +1,5 @@
+import type { SymbolUtil } from '../symbol';
+export declare type SymbolRegistrar = (this: void, symbols: SymbolUtil, ctx: SymbolRegistrarContext) => void;
+export interface SymbolRegistrarContext {
+}
+//# sourceMappingURL=SymbolRegistrar.d.ts.map

package/lib/service/SymbolRegistrar.js

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

package/lib/service/fileUtil.d.ts

@@ -0,0 +1,121 @@
+/// <reference types="node" />
+import type fs from 'fs';
+import { URL as Uri } from 'url';
+export declare type RootUriString = `${string}/`;
+export declare type FileExtension = `.${string}`;
+/**
+ * A string file path, string file URI, or a file URI object.
+ */
+export declare type PathLike = string | Uri;
+export declare namespace fileUtil {
+    /**
+     * @param rootUris The root URIs. Each URI in this array must end with a slash (`/`).
+     * @param uri The target file URI.
+     * @returns The relative path from one of the `roots` to the `uri`, or `undefined` if the `uri` is not under any roots.
+     * The separation used in the relative path is always slash (`/`).
+     * @example
+     * getRels(['file:///root/foo/', 'file:///root/'], 'file:///root/foo/bar/qux.json')
+     * // -> 'bar/qux.json'
+     * // -> 'foo/bar/qux.json'
+     * // -> undefined
+     *
+     * getRels(['file:///root/foo/', 'file:///root/'], 'file:///outsider.json')
+     * // -> undefined
+     */
+    function getRels(uri: string, rootUris: readonly RootUriString[]): Generator<string, undefined, unknown>;
+    /**
+     * @see {@link getRels}
+     * @example
+     * getRel(['file:///root/foo/', 'file:///root/'], 'file:///root/foo/bar/qux.json') // -> 'bar/qux.json'
+     * getRel(['file:///root/foo/', 'file:///root/'], 'file:///outsider.json') // -> undefined
+     */
+    function getRel(uri: string, rootUris: readonly RootUriString[]): string | undefined;
+    function isRootUri(uri: string): uri is RootUriString;
+    function ensureEndingSlash(uri: string): RootUriString;
+    function join(fromUri: string, toUri: string): string;
+    /**
+     * @throws If `uri` is not a valid URI.
+     */
+    function isFileUri(uri: string): boolean;
+    /**
+     * @returns The part from the last `.` to the end of the URI, or `undefined` if no dots exist. No special treatment for leading dots.
+     */
+    function extname(value: string): FileExtension | undefined;
+    /**
+     * @param fileUri A file URI.
+     * @returns The corresponding file path of the `fileUri` in platform-specific format.
+     * @throws If the URI is not a file schema URI.
+     */
+    function fileUriToPath(fileUri: string): string;
+    /**
+     * @param path A file path.
+     * @returns The corresponding file URI of the `path`.
+     */
+    function pathToFileUri(path: string): string;
+    function normalize(uri: string): string;
+    function getParentOfFile(path: PathLike): PathLike;
+    /**
+     * @throws
+     *
+     * @param mode Default to `0o777` (`rwxrwxrwx`)
+     */
+    function ensureDir(path: PathLike, mode?: fs.Mode): Promise<void>;
+    /**
+     * @throws
+     *
+     * Ensures the parent directory of the path exists.
+     *
+     * @param mode Default to `0o777` (`rwxrwxrwx`)
+     */
+    function ensureParentOfFile(path: PathLike, mode?: fs.Mode): Promise<void>;
+    function readFile(path: PathLike): Promise<Buffer>;
+    /**
+     * @throws
+     *
+     * The directory of the file will be created recursively if it doesn'texist.
+     *
+     * * Encoding: `utf-8`
+     * * Mode: `0o666` (`rw-rw-rw-`)
+     * * Flag: `w`
+     */
+    function writeFile(path: PathLike, data: Buffer | string): Promise<void>;
+    /**
+     * @throws
+     */
+    function readJson<T = any>(path: PathLike): Promise<T>;
+    /**
+     * @throws
+     *
+     * @see {@link writeFile}
+     */
+    function writeJson(path: PathLike, data: any): Promise<void>;
+    /**
+     * @throws
+     */
+    function readGzippedFile(path: PathLike): Promise<Buffer>;
+    /**
+     * @throws
+     */
+    function writeGzippedFile(path: PathLike, buffer: Buffer | string): Promise<void>;
+    /**
+     * @throws
+     */
+    function readGzippedJson<T = any>(path: PathLike): Promise<T>;
+    /**
+     * @throws
+     */
+    function writeGzippedJson(path: PathLike, data: any): Promise<void>;
+    /**
+     * Show the file/directory in the platform-specific explorer program.
+     *
+     * Should not be called with unsanitized user-input path due to the possibility of
+     * arbitrary code execution.
+     *
+     * @returns The `stdout` from the spawned child process.
+     */
+    function showFile(path: string): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+}
+//# sourceMappingURL=fileUtil.d.ts.map

package/lib/service/fileUtil.js

@@ -0,0 +1,268 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileUtil = void 0;
+const child_process_1 = __importDefault(require("child_process"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const process_1 = __importDefault(require("process"));
+const url_1 = __importStar(require("url"));
+const util_1 = require("util");
+const zlib_1 = __importDefault(require("zlib"));
+const common_1 = require("../common");
+var fileUtil;
+(function (fileUtil) {
+    /**
+     * @param rootUris The root URIs. Each URI in this array must end with a slash (`/`).
+     * @param uri The target file URI.
+     * @returns The relative path from one of the `roots` to the `uri`, or `undefined` if the `uri` is not under any roots.
+     * The separation used in the relative path is always slash (`/`).
+     * @example
+     * getRels(['file:///root/foo/', 'file:///root/'], 'file:///root/foo/bar/qux.json')
+     * // -> 'bar/qux.json'
+     * // -> 'foo/bar/qux.json'
+     * // -> undefined
+     *
+     * getRels(['file:///root/foo/', 'file:///root/'], 'file:///outsider.json')
+     * // -> undefined
+     */
+    function* getRels(uri, rootUris) {
+        for (const root of rootUris) {
+            if (uri.startsWith(root)) {
+                yield decodeURIComponent(uri.slice(root.length));
+            }
+        }
+        return undefined;
+    }
+    fileUtil.getRels = getRels;
+    /**
+     * @see {@link getRels}
+     * @example
+     * getRel(['file:///root/foo/', 'file:///root/'], 'file:///root/foo/bar/qux.json') // -> 'bar/qux.json'
+     * getRel(['file:///root/foo/', 'file:///root/'], 'file:///outsider.json') // -> undefined
+     */
+    function getRel(uri, rootUris) {
+        return getRels(uri, rootUris).next().value;
+    }
+    fileUtil.getRel = getRel;
+    function isRootUri(uri) {
+        return uri.endsWith('/');
+    }
+    fileUtil.isRootUri = isRootUri;
+    function ensureEndingSlash(uri) {
+        return isRootUri(uri) ? uri : `${uri}/`;
+    }
+    fileUtil.ensureEndingSlash = ensureEndingSlash;
+    function join(fromUri, toUri) {
+        return ensureEndingSlash(fromUri) + (toUri.startsWith('/') ? toUri.slice(1) : toUri);
+    }
+    fileUtil.join = join;
+    /**
+     * @throws If `uri` is not a valid URI.
+     */
+    function isFileUri(uri) {
+        return uri.startsWith('file:');
+    }
+    fileUtil.isFileUri = isFileUri;
+    /**
+     * @returns The part from the last `.` to the end of the URI, or `undefined` if no dots exist. No special treatment for leading dots.
+     */
+    function extname(value) {
+        const i = value.lastIndexOf('.');
+        return i >= 0 ? value.slice(i) : undefined;
+    }
+    fileUtil.extname = extname;
+    /* istanbul ignore next */
+    /**
+     * @param fileUri A file URI.
+     * @returns The corresponding file path of the `fileUri` in platform-specific format.
+     * @throws If the URI is not a file schema URI.
+     */
+    function fileUriToPath(fileUri) {
+        return url_1.default.fileURLToPath(new url_1.URL(fileUri));
+    }
+    fileUtil.fileUriToPath = fileUriToPath;
+    /* istanbul ignore next */
+    /**
+     * @param path A file path.
+     * @returns The corresponding file URI of the `path`.
+     */
+    function pathToFileUri(path) {
+        return url_1.default.pathToFileURL(path).toString();
+    }
+    fileUtil.pathToFileUri = pathToFileUri;
+    /* istanbul ignore next */
+    function normalize(uri) {
+        try {
+            return isFileUri(uri) ? pathToFileUri(fileUriToPath(uri)) : new url_1.URL(uri).toString();
+        }
+        catch {
+            return uri;
+        }
+    }
+    fileUtil.normalize = normalize;
+    /**
+     * @param path A string file path, string file URI, or a file URI object.
+     *
+     * @returns A {@link fs.PathLike}.
+     */
+    function toFsPathLike(path) {
+        if (typeof path === 'string' && isFileUri(path)) {
+            return new url_1.URL(path);
+        }
+        return path;
+    }
+    /* istanbul ignore next */
+    function getParentOfFile(path) {
+        if (path instanceof url_1.URL || isFileUri(path)) {
+            return new url_1.URL('.', path);
+        }
+        else {
+            return (0, path_1.resolve)(path, '..');
+        }
+    }
+    fileUtil.getParentOfFile = getParentOfFile;
+    /* istanbul ignore next */
+    /**
+     * @throws
+     *
+     * @param mode Default to `0o777` (`rwxrwxrwx`)
+     */
+    async function ensureDir(path, mode = 0o777) {
+        try {
+            await fs_1.promises.mkdir(toFsPathLike(path), { mode, recursive: true });
+        }
+        catch (e) {
+            if (!(0, common_1.isErrorCode)(e, 'EEXIST')) {
+                throw e;
+            }
+        }
+    }
+    fileUtil.ensureDir = ensureDir;
+    /* istanbul ignore next */
+    /**
+     * @throws
+     *
+     * Ensures the parent directory of the path exists.
+     *
+     * @param mode Default to `0o777` (`rwxrwxrwx`)
+     */
+    async function ensureParentOfFile(path, mode = 0o777) {
+        return ensureDir(getParentOfFile(path), mode);
+    }
+    fileUtil.ensureParentOfFile = ensureParentOfFile;
+    async function readFile(path) {
+        return fs_1.promises.readFile(toFsPathLike(path));
+    }
+    fileUtil.readFile = readFile;
+    /* istanbul ignore next */
+    /**
+     * @throws
+     *
+     * The directory of the file will be created recursively if it doesn'texist.
+     *
+     * * Encoding: `utf-8`
+     * * Mode: `0o666` (`rw-rw-rw-`)
+     * * Flag: `w`
+     */
+    async function writeFile(path, data) {
+        await ensureParentOfFile(path);
+        return fs_1.promises.writeFile(toFsPathLike(path), data);
+    }
+    fileUtil.writeFile = writeFile;
+    /* istanbul ignore next */
+    /**
+     * @throws
+     */
+    async function readJson(path) {
+        return JSON.parse((0, common_1.bufferToString)(await readFile(path)));
+    }
+    fileUtil.readJson = readJson;
+    /* istanbul ignore next */
+    /**
+     * @throws
+     *
+     * @see {@link writeFile}
+     */
+    async function writeJson(path, data) {
+        return writeFile(path, JSON.stringify(data));
+    }
+    fileUtil.writeJson = writeJson;
+    /**
+     * @throws
+     */
+    async function readGzippedFile(path) {
+        const unzip = (0, util_1.promisify)(zlib_1.default.gunzip);
+        return unzip(await readFile(path));
+    }
+    fileUtil.readGzippedFile = readGzippedFile;
+    /**
+     * @throws
+     */
+    async function writeGzippedFile(path, buffer) {
+        const zip = (0, util_1.promisify)(zlib_1.default.gzip);
+        return writeFile(path, await zip(buffer));
+    }
+    fileUtil.writeGzippedFile = writeGzippedFile;
+    /**
+     * @throws
+     */
+    async function readGzippedJson(path) {
+        return JSON.parse((0, common_1.bufferToString)(await readGzippedFile(path)));
+    }
+    fileUtil.readGzippedJson = readGzippedJson;
+    /**
+     * @throws
+     */
+    async function writeGzippedJson(path, data) {
+        return writeGzippedFile(path, JSON.stringify(data));
+    }
+    fileUtil.writeGzippedJson = writeGzippedJson;
+    /**
+     * Show the file/directory in the platform-specific explorer program.
+     *
+     * Should not be called with unsanitized user-input path due to the possibility of
+     * arbitrary code execution.
+     *
+     * @returns The `stdout` from the spawned child process.
+     */
+    async function showFile(path) {
+        const execFile = (0, util_1.promisify)(child_process_1.default.execFile);
+        let command;
+        switch (process_1.default.platform) {
+            case 'darwin':
+                command = 'open';
+                break;
+            case 'win32':
+                command = 'explorer';
+                break;
+            default:
+                command = 'xdg-open';
+                break;
+        }
+        return execFile(command, [path]);
+    }
+    fileUtil.showFile = showFile;
+})(fileUtil = exports.fileUtil || (exports.fileUtil = {}));
+//# sourceMappingURL=fileUtil.js.map

package/lib/service/index.d.ts

@@ -0,0 +1,18 @@
+export * from './CacheService';
+export * from './Config';
+export * from './Context';
+export * from './Dependency';
+export * from './Downloader';
+export * from './ErrorReporter';
+export { FileService, UriProtocolSupporter } from './FileService';
+export * from './fileUtil';
+export * from './Hover';
+export * from './Logger';
+export * from './MetaRegistry';
+export * from './Operations';
+export * from './Profiler';
+export * from './Project';
+export * from './Service';
+export * from './SymbolLocations';
+export * from './SymbolRegistrar';
+//# sourceMappingURL=index.d.ts.map