@teambit/ts-server 0.0.59 → 0.0.61

package/dist/ts-server-client.js

@@ -1,349 +1,369 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.TsserverClient = void 0;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const watcher_1 = require("@teambit/watcher");
-const command_exists_1 = __importDefault(require("command-exists"));
-const modules_resolver_1 = require("./modules-resolver");
-const process_based_tsserver_1 = require("./process-based-tsserver");
-const tsp_command_types_1 = require("./tsp-command-types");
-const utils_1 = require("./utils");
-const format_diagnostics_1 = require("./format-diagnostics");
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _watcher() {
+  const data = require("@teambit/watcher");
+  _watcher = function () {
+    return data;
+  };
+  return data;
+}
+function _commandExists() {
+  const data = _interopRequireDefault(require("command-exists"));
+  _commandExists = function () {
+    return data;
+  };
+  return data;
+}
+function _modulesResolver() {
+  const data = require("./modules-resolver");
+  _modulesResolver = function () {
+    return data;
+  };
+  return data;
+}
+function _processBasedTsserver() {
+  const data = require("./process-based-tsserver");
+  _processBasedTsserver = function () {
+    return data;
+  };
+  return data;
+}
+function _tspCommandTypes() {
+  const data = require("./tsp-command-types");
+  _tspCommandTypes = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("./utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _formatDiagnostics() {
+  const data = require("./format-diagnostics");
+  _formatDiagnostics = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class TsserverClient {
-    constructor(
-    /**
-     * absolute root path of the project.
-     */
-    projectPath, logger, options = {}, 
-    /**
-     * provide files if you want to check types on init. (options.checkTypes should be enabled).
-     * paths should be absolute.
-     */
-    files = []) {
-        this.projectPath = projectPath;
-        this.logger = logger;
-        this.options = options;
-        this.files = files;
-        this.lastDiagnostics = [];
-        this.serverRunning = false;
-    }
-    /**
-     * start the ts-server and keep its process alive.
-     * this methods returns pretty fast. if checkTypes is enabled, it runs the process in the background and
-     * doesn't wait for it.
-     */
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.tsServer = new process_based_tsserver_1.ProcessBasedTsServer({
-                    logger: this.logger,
-                    tsserverPath: this.findTsserverPath(),
-                    logToConsole: this.options.verbose,
-                    onEvent: this.onTsserverEvent.bind(this),
-                });
-                this.tsServer
-                    .start()
-                    .then(() => {
-                    this.serverRunning = true;
-                })
-                    .catch((err) => {
-                    this.logger.error('TsserverClient.init failed', err);
-                });
-                if (this.files.length) {
-                    const openPromises = this.files.map((file) => this.open(file));
-                    yield Promise.all(openPromises.map((promise) => promise.catch((error) => error)));
-                    const failedFiles = openPromises.filter((promise) => promise instanceof Error);
-                    if (failedFiles.length > 0) {
-                        this.logger.error('TsserverClient.init failed to open files:', failedFiles);
-                    }
-                    if (failedFiles.length > 0) {
-                        this.logger.error('TsserverClient.init failed to open files:', failedFiles);
-                    }
-                    this.checkTypesIfNeeded();
-                }
-                this.logger.debug('TsserverClient.init completed');
-            }
-            catch (err) {
-                this.logger.error('TsserverClient.init failed', err);
-            }
-        });
-    }
-    checkTypesIfNeeded(files = this.files) {
-        if (!this.shouldCheckTypes()) {
-            return;
+  lastDiagnostics = [];
+  serverRunning = false;
+  constructor(
+  /**
+   * absolute root path of the project.
+   */
+  projectPath, logger, options = {},
+  /**
+   * provide files if you want to check types on init. (options.checkTypes should be enabled).
+   * paths should be absolute.
+   */
+  files = []) {
+    this.projectPath = projectPath;
+    this.logger = logger;
+    this.options = options;
+    this.files = files;
+  }
+
+  /**
+   * start the ts-server and keep its process alive.
+   * this methods returns pretty fast. if checkTypes is enabled, it runs the process in the background and
+   * doesn't wait for it.
+   */
+  async init() {
+    try {
+      this.tsServer = new (_processBasedTsserver().ProcessBasedTsServer)({
+        logger: this.logger,
+        tsserverPath: this.findTsserverPath(),
+        logToConsole: this.options.verbose,
+        onEvent: this.onTsserverEvent.bind(this)
+      });
+      this.tsServer.start().then(() => {
+        this.serverRunning = true;
+      }).catch(err => {
+        this.logger.error('TsserverClient.init failed', err);
+      });
+      if (this.files.length) {
+        const openPromises = this.files.map(file => this.open(file));
+        await Promise.all(openPromises.map(promise => promise.catch(error => error)));
+        const failedFiles = openPromises.filter(promise => promise instanceof Error);
+        if (failedFiles.length > 0) {
+          this.logger.error('TsserverClient.init failed to open files:', failedFiles);
         }
-        const start = Date.now();
-        this.getDiagnostic(files)
-            .then(() => {
-            const end = Date.now() - start;
-            const msg = `completed type checking (${end / 1000} sec)`;
-            if (this.lastDiagnostics.length) {
-                this.logger.consoleFailure(`${msg}. found errors in ${this.lastDiagnostics.length} files.`);
-            }
-            else {
-                this.logger.consoleSuccess(`${msg}. no errors were found.`);
-            }
-        })
-            .catch((err) => {
-            const msg = `failed getting the type errors from ts-server`;
-            this.logger.console(msg);
-            this.logger.error(msg, err);
-        });
-    }
-    shouldCheckTypes() {
-        // this also covers this.options.checkTypes !== CheckTypes.None.
-        return Boolean(this.options.checkTypes);
-    }
-    /**
-     * if `bit watch` or `bit start` are running in the background, this method is triggered.
-     */
-    onFileChange(file) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.changed(file);
-            const files = this.options.checkTypes === watcher_1.CheckTypes.ChangedFile ? [file] : undefined;
-            this.checkTypesIfNeeded(files);
-        });
-    }
-    killTsServer() {
-        if (this.tsServer && this.serverRunning) {
-            this.tsServer.kill();
-            this.tsServer = null;
-            this.serverRunning = false;
+        if (failedFiles.length > 0) {
+          this.logger.error('TsserverClient.init failed to open files:', failedFiles);
         }
+        this.checkTypesIfNeeded();
+      }
+      this.logger.debug('TsserverClient.init completed');
+    } catch (err) {
+      this.logger.error('TsserverClient.init failed', err);
     }
-    isServerRunning() {
-        return this.serverRunning;
-    }
-    /**
-     * get diagnostic of all files opened in the project.
-     * there is little to no value of getting diagnostic for a specific file, as
-     * changing a type in one file may cause errors in different files.
-     *
-     * the errors/diagnostic info are sent as events, see this.onTsserverEvent() for more info.
-     *
-     * the return value here just shows whether the request was succeeded, it doesn't have any info about whether errors
-     * were found or not.
-     */
-    getDiagnostic(files = this.files) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            this.lastDiagnostics = [];
-            return (_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.request(tsp_command_types_1.CommandTypes.Geterr, { delay: 0, files });
-        });
-    }
-    /**
-     * avoid using this method, it takes longer than `getDiagnostic()` and shows errors from paths outside the project
-     */
-    getDiagnosticAllProject(requestedByFile) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            return (_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.request(tsp_command_types_1.CommandTypes.GeterrForProject, { file: requestedByFile, delay: 0 });
-        });
-    }
-    /**
-     * @param file can be absolute or relative to this.projectRoot.
-     */
-    getQuickInfo(file, position) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const absFile = this.convertFileToAbsoluteIfNeeded(file);
-            yield this.openIfNeeded(absFile);
-            return (_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.request(tsp_command_types_1.CommandTypes.Quickinfo, {
-                file: absFile,
-                line: position.line,
-                offset: position.character,
-            });
-        });
-    }
-    /**
-     * @param file can be absolute or relative to this.projectRoot.
-     */
-    getTypeDefinition(file, position) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const absFile = this.convertFileToAbsoluteIfNeeded(file);
-            yield this.openIfNeeded(absFile);
-            return (_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.request(tsp_command_types_1.CommandTypes.TypeDefinition, {
-                file: absFile,
-                line: position.line,
-                offset: position.character,
-            });
-        });
+  }
+  checkTypesIfNeeded(files = this.files) {
+    if (!this.shouldCheckTypes()) {
+      return;
     }
-    getDefinition(file, position) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const absFile = this.convertFileToAbsoluteIfNeeded(file);
-            yield this.openIfNeeded(absFile);
-            const response = yield ((_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.request(tsp_command_types_1.CommandTypes.Definition, {
-                file: absFile,
-                line: position.line,
-                offset: position.character,
-            }));
-            if (!(response === null || response === void 0 ? void 0 : response.success)) {
-                // TODO: we need a function to handle responses properly here for all.
-                this.logger.warn(`For file ${absFile} tsserver failed to request definition info`);
-                return response;
-            }
-            return response;
-        });
+    const start = Date.now();
+    this.getDiagnostic(files).then(() => {
+      const end = Date.now() - start;
+      const msg = `completed type checking (${end / 1000} sec)`;
+      if (this.lastDiagnostics.length) {
+        this.logger.consoleFailure(`${msg}. found errors in ${this.lastDiagnostics.length} files.`);
+      } else {
+        this.logger.consoleSuccess(`${msg}. no errors were found.`);
+      }
+    }).catch(err => {
+      const msg = `failed getting the type errors from ts-server`;
+      this.logger.console(msg);
+      this.logger.error(msg, err);
+    });
+  }
+  shouldCheckTypes() {
+    // this also covers this.options.checkTypes !== CheckTypes.None.
+    return Boolean(this.options.checkTypes);
+  }
+
+  /**
+   * if `bit watch` or `bit start` are running in the background, this method is triggered.
+   */
+  async onFileChange(file) {
+    await this.changed(file);
+    const files = this.options.checkTypes === _watcher().CheckTypes.ChangedFile ? [file] : undefined;
+    this.checkTypesIfNeeded(files);
+  }
+  killTsServer() {
+    if (this.tsServer && this.serverRunning) {
+      this.tsServer.kill();
+      this.tsServer = null;
+      this.serverRunning = false;
     }
-    /**
-     * @param file can be absolute or relative to this.projectRoot.
-     */
-    getReferences(file, position) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const absFile = this.convertFileToAbsoluteIfNeeded(file);
-            yield this.openIfNeeded(absFile);
-            return (_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.request(tsp_command_types_1.CommandTypes.References, {
-                file: absFile,
-                line: position.line,
-                offset: position.character,
-            });
-        });
+  }
+  isServerRunning() {
+    return this.serverRunning;
+  }
+
+  /**
+   * get diagnostic of all files opened in the project.
+   * there is little to no value of getting diagnostic for a specific file, as
+   * changing a type in one file may cause errors in different files.
+   *
+   * the errors/diagnostic info are sent as events, see this.onTsserverEvent() for more info.
+   *
+   * the return value here just shows whether the request was succeeded, it doesn't have any info about whether errors
+   * were found or not.
+   */
+  async getDiagnostic(files = this.files) {
+    this.lastDiagnostics = [];
+    return this.tsServer?.request(_tspCommandTypes().CommandTypes.Geterr, {
+      delay: 0,
+      files
+    });
+  }
+
+  /**
+   * avoid using this method, it takes longer than `getDiagnostic()` and shows errors from paths outside the project
+   */
+  async getDiagnosticAllProject(requestedByFile) {
+    return this.tsServer?.request(_tspCommandTypes().CommandTypes.GeterrForProject, {
+      file: requestedByFile,
+      delay: 0
+    });
+  }
+
+  /**
+   * @param file can be absolute or relative to this.projectRoot.
+   */
+  async getQuickInfo(file, position) {
+    const absFile = this.convertFileToAbsoluteIfNeeded(file);
+    await this.openIfNeeded(absFile);
+    return this.tsServer?.request(_tspCommandTypes().CommandTypes.Quickinfo, {
+      file: absFile,
+      line: position.line,
+      offset: position.character
+    });
+  }
+
+  /**
+   * @param file can be absolute or relative to this.projectRoot.
+   */
+  async getTypeDefinition(file, position) {
+    const absFile = this.convertFileToAbsoluteIfNeeded(file);
+    await this.openIfNeeded(absFile);
+    return this.tsServer?.request(_tspCommandTypes().CommandTypes.TypeDefinition, {
+      file: absFile,
+      line: position.line,
+      offset: position.character
+    });
+  }
+  async getDefinition(file, position) {
+    const absFile = this.convertFileToAbsoluteIfNeeded(file);
+    await this.openIfNeeded(absFile);
+    const response = await this.tsServer?.request(_tspCommandTypes().CommandTypes.Definition, {
+      file: absFile,
+      line: position.line,
+      offset: position.character
+    });
+    if (!response?.success) {
+      // TODO: we need a function to handle responses properly here for all.
+      this.logger.warn(`For file ${absFile} tsserver failed to request definition info`);
+      return response;
     }
-    /**
-     * @param file can be absolute or relative to this.projectRoot.
-     */
-    getSignatureHelp(file, position) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const absFile = this.convertFileToAbsoluteIfNeeded(file);
-            yield this.openIfNeeded(absFile);
-            return (_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.request(tsp_command_types_1.CommandTypes.SignatureHelp, {
-                file: absFile,
-                line: position.line,
-                offset: position.character,
-            });
-        });
+    return response;
+  }
+
+  /**
+   * @param file can be absolute or relative to this.projectRoot.
+   */
+  async getReferences(file, position) {
+    const absFile = this.convertFileToAbsoluteIfNeeded(file);
+    await this.openIfNeeded(absFile);
+    return this.tsServer?.request(_tspCommandTypes().CommandTypes.References, {
+      file: absFile,
+      line: position.line,
+      offset: position.character
+    });
+  }
+
+  /**
+   * @param file can be absolute or relative to this.projectRoot.
+   */
+  async getSignatureHelp(file, position) {
+    const absFile = this.convertFileToAbsoluteIfNeeded(file);
+    await this.openIfNeeded(absFile);
+    return this.tsServer?.request(_tspCommandTypes().CommandTypes.SignatureHelp, {
+      file: absFile,
+      line: position.line,
+      offset: position.character
+    });
+  }
+  async configure(configureArgs = {}) {
+    return this.tsServer?.request(_tspCommandTypes().CommandTypes.Configure, configureArgs);
+  }
+
+  /**
+   * ask tsserver to open a file if it was not opened before.
+   * @param file absolute path of the file
+   */
+  async openIfNeeded(file) {
+    if (this.files.includes(file)) {
+      return;
     }
-    configure(configureArgs = {}) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            return (_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.request(tsp_command_types_1.CommandTypes.Configure, configureArgs);
-        });
+    await this.open(file);
+    this.files.push(file);
+  }
+  async open(file) {
+    return this.tsServer?.notify(_tspCommandTypes().CommandTypes.Open, {
+      file,
+      projectRootPath: this.projectPath
+    });
+  }
+  async close(file) {
+    await this.tsServer?.notify(_tspCommandTypes().CommandTypes.Close, {
+      file
+    });
+    this.files = this.files.filter(openFile => openFile !== file);
+  }
+
+  /**
+   * since Bit is not an IDE, it doesn't have the information such as the exact line/offset of the changes.
+   * as a workaround, to tell tsserver what was changed, we pretend that the entire file was cleared and new text was
+   * added. this is the only way I could find to tell tsserver about the change. otherwise, tsserver keep assuming that
+   * the file content remained the same. (closing/re-opening the file doesn't help).
+   */
+  async changed(file) {
+    // tell tsserver that all content was removed
+    await this.tsServer?.notify(_tspCommandTypes().CommandTypes.Change, {
+      file,
+      line: 1,
+      offset: 1,
+      endLine: 99999,
+      endOffset: 1,
+      insertString: ''
+    });
+    const content = await _fsExtra().default.readFile(file, 'utf-8');
+
+    // tell tsserver that all file content was added
+    await this.tsServer?.notify(_tspCommandTypes().CommandTypes.Change, {
+      file,
+      line: 1,
+      offset: 1,
+      endLine: 1,
+      endOffset: 1,
+      insertString: content
+    });
+  }
+  onTsserverEvent(event) {
+    switch (event.event) {
+      case _tspCommandTypes().EventName.semanticDiag:
+      case _tspCommandTypes().EventName.syntaxDiag:
+        this.publishDiagnostic(event);
+        break;
+      default:
+        this.logger.debug(`ignored TsServer event: ${event.event}`);
     }
-    /**
-     * ask tsserver to open a file if it was not opened before.
-     * @param file absolute path of the file
-     */
-    openIfNeeded(file) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.files.includes(file)) {
-                return;
-            }
-            yield this.open(file);
-            this.files.push(file);
-        });
+  }
+  convertFileToAbsoluteIfNeeded(filepath) {
+    if (_path().default.isAbsolute(filepath)) {
+      return filepath;
     }
-    open(file) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            return (_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.notify(tsp_command_types_1.CommandTypes.Open, {
-                file,
-                projectRootPath: this.projectPath,
-            });
-        });
+    return _path().default.join(this.projectPath, filepath);
+  }
+  publishDiagnostic(message) {
+    if (!message.body?.diagnostics.length || !this.options.printTypeErrors) {
+      return;
     }
-    close(file) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            yield ((_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.notify(tsp_command_types_1.CommandTypes.Close, {
-                file,
-            }));
-            this.files = this.files.filter((openFile) => openFile !== file);
-        });
+    this.lastDiagnostics.push(message.body);
+    const file = _path().default.relative(this.projectPath, message.body.file);
+    message.body.diagnostics.forEach(diag => this.logger.console((0, _formatDiagnostics().formatDiagnostic)(diag, file)));
+  }
+
+  /**
+   * copied over from https://github.com/typescript-language-server/typescript-language-server/blob/master/src/lsp-server.ts
+   */
+  findTsserverPath() {
+    if (this.options.tsServerPath) {
+      return this.options.tsServerPath;
     }
+    const tsServerPath = _path().default.join('typescript', 'lib', 'tsserver.js');
+
     /**
-     * since Bit is not an IDE, it doesn't have the information such as the exact line/offset of the changes.
-     * as a workaround, to tell tsserver what was changed, we pretend that the entire file was cleared and new text was
-     * added. this is the only way I could find to tell tsserver about the change. otherwise, tsserver keep assuming that
-     * the file content remained the same. (closing/re-opening the file doesn't help).
+     * (1) find it in the bit directory
      */
-    changed(file) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            // tell tsserver that all content was removed
-            yield ((_a = this.tsServer) === null || _a === void 0 ? void 0 : _a.notify(tsp_command_types_1.CommandTypes.Change, {
-                file,
-                line: 1,
-                offset: 1,
-                endLine: 99999,
-                endOffset: 1,
-                insertString: '',
-            }));
-            const content = yield fs_extra_1.default.readFile(file, 'utf-8');
-            // tell tsserver that all file content was added
-            yield ((_b = this.tsServer) === null || _b === void 0 ? void 0 : _b.notify(tsp_command_types_1.CommandTypes.Change, {
-                file,
-                line: 1,
-                offset: 1,
-                endLine: 1,
-                endOffset: 1,
-                insertString: content,
-            }));
-        });
-    }
-    onTsserverEvent(event) {
-        switch (event.event) {
-            case tsp_command_types_1.EventName.semanticDiag:
-            case tsp_command_types_1.EventName.syntaxDiag:
-                this.publishDiagnostic(event);
-                break;
-            default:
-                this.logger.debug(`ignored TsServer event: ${event.event}`);
-        }
-    }
-    convertFileToAbsoluteIfNeeded(filepath) {
-        if (path_1.default.isAbsolute(filepath)) {
-            return filepath;
-        }
-        return path_1.default.join(this.projectPath, filepath);
-    }
-    publishDiagnostic(message) {
-        var _a;
-        if (!((_a = message.body) === null || _a === void 0 ? void 0 : _a.diagnostics.length) || !this.options.printTypeErrors) {
-            return;
-        }
-        this.lastDiagnostics.push(message.body);
-        const file = path_1.default.relative(this.projectPath, message.body.file);
-        message.body.diagnostics.forEach((diag) => this.logger.console((0, format_diagnostics_1.formatDiagnostic)(diag, file)));
+    const bundled = (0, _modulesResolver().findPathToModule)(__dirname, tsServerPath);
+    if (bundled) {
+      return bundled;
     }
-    /**
-     * copied over from https://github.com/typescript-language-server/typescript-language-server/blob/master/src/lsp-server.ts
-     */
-    findTsserverPath() {
-        if (this.options.tsServerPath) {
-            return this.options.tsServerPath;
-        }
-        const tsServerPath = path_1.default.join('typescript', 'lib', 'tsserver.js');
-        /**
-         * (1) find it in the bit directory
-         */
-        const bundled = (0, modules_resolver_1.findPathToModule)(__dirname, tsServerPath);
-        if (bundled) {
-            return bundled;
-        }
-        // (2) use globally installed tsserver
-        if (command_exists_1.default.sync((0, utils_1.getTsserverExecutable)())) {
-            return (0, utils_1.getTsserverExecutable)();
-        }
-        throw new Error(`Couldn't find '${(0, utils_1.getTsserverExecutable)()}' executable or 'tsserver.js' module`);
+
+    // (2) use globally installed tsserver
+    if (_commandExists().default.sync((0, _utils().getTsserverExecutable)())) {
+      return (0, _utils().getTsserverExecutable)();
     }
+    throw new Error(`Couldn't find '${(0, _utils().getTsserverExecutable)()}' executable or 'tsserver.js' module`);
+  }
 }
 exports.TsserverClient = TsserverClient;
+
 //# sourceMappingURL=ts-server-client.js.map