@botpress/cli 0.0.2

package/dist/app/integration-ref.js

@@ -0,0 +1,61 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var integration_ref_exports = {};
+__export(integration_ref_exports, {
+  formatIntegrationRef: () => formatIntegrationRef,
+  parseIntegrationRef: () => parseIntegrationRef
+});
+module.exports = __toCommonJS(integration_ref_exports);
+var import_semver = __toESM(require("semver"));
+var uuid = __toESM(require("uuid"));
+const LATEST_TAG = "latest";
+const formatIntegrationRef = (ref) => {
+  if (ref.type === "id") {
+    return ref.id;
+  }
+  return `${ref.name}@${ref.version}`;
+};
+const parseIntegrationRef = (ref) => {
+  if (uuid.validate(ref)) {
+    return { type: "id", id: ref };
+  }
+  if (!ref.includes("@")) {
+    return { type: "name", name: ref, version: LATEST_TAG };
+  }
+  const [name, version] = ref.split("@");
+  if (!name || !version) {
+    return;
+  }
+  const cleanedVersion = version === LATEST_TAG ? version : import_semver.default.clean(version);
+  if (!cleanedVersion) {
+    return;
+  }
+  return { type: "name", name, version: cleanedVersion };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatIntegrationRef,
+  parseIntegrationRef
+});

package/dist/app/project.js

@@ -0,0 +1,502 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var project_exports = {};
+__export(project_exports, {
+  ProjectCommands: () => ProjectCommands,
+  ProjectPaths: () => ProjectPaths
+});
+module.exports = __toCommonJS(project_exports);
+var bpclient = __toESM(require("@botpress/client"));
+var import_bluebird = __toESM(require("bluebird"));
+var import_chalk = __toESM(require("chalk"));
+var import_fs = __toESM(require("fs"));
+var import_lodash = __toESM(require("lodash"));
+var import_path = __toESM(require("path"));
+var import_prompts = __toESM(require("prompts"));
+var consts = __toESM(require("../const"));
+var pathutils = __toESM(require("../paths"));
+var requireutils = __toESM(require("../requires"));
+var import_worker = require("../worker");
+var import_api_utils = require("./api-utils");
+var import_base = require("./base");
+var errors = __toESM(require("./errors"));
+var esbuild = __toESM(require("./esbuild"));
+var generator = __toESM(require("./generator"));
+var import_integration_ref = require("./integration-ref");
+class ProjectPaths {
+  abs;
+  rel;
+  static from(paths, overrides) {
+    const rel = { ...paths.rel, ...overrides };
+    return new ProjectPaths(rel);
+  }
+  constructor({ workDir, definition, entryPoint: entrypoint, outDir }) {
+    const absWorkdir = pathutils.absoluteFrom(pathutils.cwd(), workDir);
+    const absDefinition = pathutils.absoluteFrom(absWorkdir, definition);
+    const absEntrypoint = pathutils.absoluteFrom(absWorkdir, entrypoint);
+    const absOutdir = pathutils.absoluteFrom(absWorkdir, outDir);
+    this.abs = { workDir: absWorkdir, definition: absDefinition, entryPoint: absEntrypoint, outDir: absOutdir };
+    const relDefinition = pathutils.relativeFrom(this.abs.workDir, this.abs.definition);
+    const relEntrypoint = pathutils.relativeFrom(this.abs.workDir, this.abs.entryPoint);
+    const relOutdir = pathutils.relativeFrom(this.abs.workDir, this.abs.outDir);
+    const relWorkdir = ".";
+    this.rel = { workDir: relWorkdir, definition: relDefinition, entryPoint: relEntrypoint, outDir: relOutdir };
+  }
+}
+const ENTRY_CODE = (entrypoint) => {
+  const unixPath = pathutils.toUnix(entrypoint);
+  const importFrom = pathutils.rmExtension(unixPath);
+  return `
+import x from './${importFrom}'
+export default x
+export const handler = x.handler
+`;
+};
+class ProjectCommands extends import_base.BaseCommands {
+  constructor(_props, _paths, _projectCache, _userCache, logger) {
+    super(logger);
+    this._props = _props;
+    this._paths = _paths;
+    this._projectCache = _projectCache;
+    this._userCache = _userCache;
+  }
+  async installIntegration(integrationRef, argv) {
+    const integrationDef = await this._readIntegrationDefinitionFromFS();
+    if (integrationDef) {
+      throw new errors.ExclusiveBotFeatureError();
+    }
+    const api = await this._ensureLoginAndCreateClient(argv);
+    const parsedRef = (0, import_integration_ref.parseIntegrationRef)(integrationRef);
+    if (!parsedRef) {
+      throw new errors.InvalidIntegrationReferenceError(integrationRef);
+    }
+    const integration = await api.findIntegration(parsedRef);
+    if (!integration) {
+      throw new errors.BotpressCLIError(`Integration "${integrationRef}" not found`);
+    }
+    const allInstances = await this._listIntegrationInstances();
+    const existingInstance = allInstances.find((i) => i.name === integration.name);
+    if (existingInstance) {
+      this._logger.warn(`Integration with name "${integration.name}" already installed.`);
+      const res = await this._confirm("Do you want to overwrite the existing instance?");
+      if (!res) {
+        this._logger.log("Aborted");
+        return;
+      }
+      await this._uninstallIntegration(existingInstance);
+    }
+    await this._generateIntegrationInstance(integration);
+  }
+  async buildProject(argv) {
+    const { abs } = this._paths;
+    const t0 = Date.now();
+    const integrationDef = await this._readIntegrationDefinitionFromFS();
+    if (integrationDef) {
+      await this._generateImplementationTypings(integrationDef);
+      await import_fs.default.promises.writeFile(consts.defDataOutfile(abs.outDir), JSON.stringify(integrationDef, void 0, 2));
+    }
+    await this.bundleProject(argv);
+    const dt = Date.now() - t0;
+    this._logger.log(`Build completed in ${dt}ms`);
+  }
+  async serveProject(argv) {
+    const { abs } = this._paths;
+    const outfile = consts.outfile(abs.outDir);
+    if (!import_fs.default.existsSync(outfile)) {
+      throw new errors.NoBundleFoundError();
+    }
+    const isIntegration = !!await this._readIntegrationDefinitionFromFS();
+    this._logger.log(`Serving ${isIntegration ? "integration" : "bot"}...`);
+    const { default: serveable } = requireutils.requireJsFile(outfile);
+    return serveable.start(argv.port);
+  }
+  async bundleProject(_argv) {
+    const integrationDef = await this._readIntegrationDefinitionFromFS();
+    const { rel, abs } = this._paths;
+    const line = this._logger.line();
+    const logLevel = this._props.verbose ? "info" : "silent";
+    try {
+      if (integrationDef) {
+        const { name } = integrationDef;
+        line.started(`Bundling integration ${import_chalk.default.bold(name)}...`);
+      } else {
+        line.started("Bundling bot...");
+      }
+      const code = ENTRY_CODE(rel.entryPoint);
+      const outfile = consts.outfile(rel.outDir);
+      line.debug(`Writing bundle to ${outfile}`);
+      await esbuild.buildCode({ code, cwd: abs.workDir, outfile, logLevel, write: true });
+      line.success(`Bundle available at ${import_chalk.default.grey(rel.outDir)}`);
+    } finally {
+      line.commit();
+    }
+  }
+  async generateTypings(_argv) {
+    const integrationDefinition = await this._readIntegrationDefinitionFromFS();
+    if (!integrationDefinition) {
+      this._logger.warn("No typings to generate for bot");
+      return;
+    }
+    return this._generateImplementationTypings(integrationDefinition);
+  }
+  async deployProject(argv) {
+    const api = await this._ensureLoginAndCreateClient(argv);
+    if (api.host !== consts.defaultBotpressApi) {
+      this._logger.log(`Using custom host ${api.host}`);
+    }
+    if (!argv.noBuild) {
+      await this.buildProject(argv);
+    }
+    const integrationDef = await this._readIntegrationDefinitionFromFS();
+    if (integrationDef) {
+      return this._deployIntegration(api, integrationDef);
+    }
+    return this._deployBot(api, argv.botId);
+  }
+  async devProject(argv) {
+    this._logger.warn("This command is experimental and subject to breaking changes without notice.");
+    const { abs } = this._paths;
+    const outfile = consts.outfile(abs.outDir);
+    if (!import_fs.default.existsSync(outfile)) {
+      throw new errors.NoBundleFoundError();
+    }
+    if (!argv.noBuild) {
+      await this.buildProject(argv);
+    }
+    const api = await this._ensureLoginAndCreateClient(argv);
+    const integrationDef = await this._readIntegrationDefinitionFromFS();
+    const { cleanup } = await this._createDevRessource(api, argv.url, integrationDef);
+    try {
+      const importPath = pathutils.toUnix(outfile);
+      const code = `require('${importPath}').default.start(${argv.port})`;
+      await (0, import_worker.spawnChildProcess)(
+        {
+          type: "code",
+          code,
+          env: {
+            BP_API_URL: api.host,
+            BP_TOKEN: api.token
+          }
+        },
+        this._logger
+      );
+    } finally {
+      this._logger.log("Cleaning up ressources...");
+      await cleanup();
+    }
+  }
+  async _createDevRessource(api, externalUrl, integrationDef) {
+    if (integrationDef) {
+      const { integration } = await api.client.createIntegration({
+        ...integrationDef,
+        dev: true,
+        url: externalUrl
+      }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, `Could not deploy dev integration "${integrationDef.name}"`);
+      });
+      this._logger.success(`Dev Integration created with id "${integration.id}"`);
+      return {
+        cleanup: () => api.client.deleteIntegration({ id: integration.id }).then(() => {
+        }).catch((thrown) => {
+          throw errors.BotpressCLIError.wrap(thrown, `Could not delete dev integration "${integrationDef.name}"`);
+        })
+      };
+    }
+    const { abs } = this._paths;
+    const outfile = consts.outfile(abs.outDir);
+    const {
+      default: { integrations: integrationList }
+    } = requireutils.requireJsFile(outfile);
+    const { bot: createdBot } = await api.client.createBot({
+      dev: true,
+      url: externalUrl
+    }).catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not deploy dev bot");
+    });
+    const integrations = (0, import_lodash.default)(integrationList ?? []).keyBy((i) => i.id).mapValues(({ enabled, configuration }) => ({ enabled, configuration })).value();
+    this._logger.debug("Bot created, updating integrations...", { integrations });
+    const { bot: updatedBot } = await api.client.updateBot({ id: createdBot.id, integrations }).catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not deploy dev bot");
+    });
+    this._logger.success(`Dev Bot created with id "${updatedBot.id}"`);
+    this._displayWebhookUrls(updatedBot);
+    return {
+      cleanup: () => api.client.deleteBot({ id: updatedBot.id }).then(() => {
+      }).catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, "Could not delete dev bot");
+      })
+    };
+  }
+  async _deployIntegration(api, integrationDef) {
+    const { abs } = this._paths;
+    const outfile = consts.outfile(abs.outDir);
+    const code = await import_fs.default.promises.readFile(outfile, "utf-8");
+    const { name, version } = integrationDef;
+    const integration = await api.findIntegration({ type: "name", name, version });
+    let message;
+    if (integration) {
+      this._logger.warn("Integration already exists. If you decide to deploy, it will overwrite the existing one.");
+      message = `Are you sure you want to override integration ${integrationDef.name} v${integrationDef.version}?`;
+    } else {
+      message = `Are you sure you want to deploy integration ${integrationDef.name} v${integrationDef.version}?`;
+    }
+    const confirm = await this._confirm(message);
+    if (!confirm) {
+      this._logger.log("Aborted");
+      return;
+    }
+    const line = this._logger.line();
+    try {
+      line.started(`Deploying integration ${import_chalk.default.bold(integrationDef.name)} v${integrationDef.version}...`);
+      if (integration) {
+        await api.client.updateIntegration({ id: integration.id, ...integrationDef, code });
+      } else {
+        await api.client.createIntegration({ ...integrationDef, code });
+      }
+      line.success("Integration deployed");
+    } catch (thrown) {
+      const action = integration ? "update" : "create";
+      throw errors.BotpressCLIError.wrap(thrown, `Could not ${action} integration "${integrationDef.name}"`);
+    } finally {
+      line.commit();
+    }
+  }
+  async _deployBot(api, botId) {
+    const { abs } = this._paths;
+    const outfile = consts.outfile(abs.outDir);
+    const code = await import_fs.default.promises.readFile(outfile, "utf-8");
+    const { default: botImpl } = requireutils.requireJsFile(outfile);
+    const { tags, states, integrations: integrationList } = botImpl;
+    const promptedBotId = await this._projectCache.sync("botId", botId, async (defaultId) => {
+      const userBots = await api.listAllPages(api.client.listBots, "bots").catch((thrown) => {
+        throw errors.BotpressCLIError.wrap(thrown, "Could not fetch existing bots");
+      });
+      if (!userBots.length) {
+        throw new errors.NoBotsFoundError();
+      }
+      const initial = userBots.find((bot) => bot.id === defaultId);
+      const { prompted } = await (0, import_prompts.default)({
+        type: "autocomplete",
+        name: "prompted",
+        message: "Which bot do you want to deploy?",
+        initial: initial?.name,
+        choices: userBots.map((bot) => ({ title: bot.name, value: bot.id }))
+      });
+      if (!prompted) {
+        throw new errors.ParamRequiredError("Bot Id");
+      }
+      return prompted;
+    });
+    const { bot: botInfo } = await api.client.getBot({ id: promptedBotId }).catch((thrown) => {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not get bot info");
+    });
+    const integrationsToUninstall = (0, import_lodash.default)(botInfo.integrations).keys().filter((key) => !integrationList?.map((i) => i.id).includes(key)).zipObject().mapValues(() => null).value();
+    const integrationsToInstall = (0, import_lodash.default)(integrationList ?? []).keyBy((i) => i.id).mapValues(({ enabled, configuration }) => ({ enabled, configuration })).value();
+    const integrations = { ...integrationsToUninstall, ...integrationsToInstall };
+    const confirm = await this._confirm(`Are you sure you want to deploy bot ${botInfo.name} ?`);
+    if (!confirm) {
+      this._logger.log("Aborted");
+      return;
+    }
+    const line = this._logger.line();
+    try {
+      line.started(`Deploying bot ${import_chalk.default.bold(botInfo.name)}...`);
+      const { bot: updatedBot } = await api.client.updateBot({
+        id: promptedBotId,
+        code,
+        states,
+        tags,
+        integrations
+      });
+      line.success("Bot deployed");
+      this._displayWebhookUrls(updatedBot);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not update bot");
+    } finally {
+      line.commit();
+    }
+  }
+  _displayWebhookUrls(bot) {
+    if (!import_lodash.default.keys(bot.integrations).length) {
+      this._logger.log("No integrations in bot");
+      return;
+    }
+    this._logger.log("Integrations:");
+    for (const integration of Object.values(bot.integrations)) {
+      if (!integration.enabled) {
+        this._logger.log(`${import_chalk.default.grey(integration.name)} ${import_chalk.default.italic("(disabled)")}: ${integration.webhookUrl}`, {
+          prefix: { symbol: "\u25CB", indent: 2 }
+        });
+      } else {
+        this._logger.log(`${import_chalk.default.bold(integration.name)} : ${integration.webhookUrl}`, {
+          prefix: { symbol: "\u25CF", indent: 2 }
+        });
+      }
+    }
+  }
+  async _listIntegrationInstances() {
+    const { abs } = this._paths;
+    const installPath = consts.installDir(abs.outDir);
+    if (!import_fs.default.existsSync(installPath)) {
+      this._logger.debug("Install path does not exist. Skipping listing of integration instances");
+      return [];
+    }
+    const allFiles = await import_fs.default.promises.readdir(installPath);
+    const allPaths = allFiles.map((name) => import_path.default.join(installPath, name));
+    const directories = await import_bluebird.default.filter(allPaths, async (path) => {
+      const stat = await import_fs.default.promises.stat(path);
+      return stat.isDirectory();
+    });
+    let jsons = directories.map((root) => ({ root, json: import_path.default.join(root, generator.INTEGRATION_JSON) }));
+    jsons = jsons.filter(({ json: x }) => import_fs.default.existsSync(x));
+    return import_bluebird.default.map(jsons, async ({ root, json }) => {
+      const content = await import_fs.default.promises.readFile(json, "utf-8");
+      const { name, version, id } = JSON.parse(content);
+      const dirname = import_path.default.basename(root);
+      return {
+        dirname,
+        id,
+        name,
+        version
+      };
+    });
+  }
+  async _confirm(message) {
+    if (this._props.confirm) {
+      this._logger.debug(`Confirming automatically: ${message}`);
+      return true;
+    }
+    const { confirm } = await (0, import_prompts.default)({
+      type: "confirm",
+      name: "confirm",
+      message,
+      initial: false
+    });
+    if (!confirm) {
+      return false;
+    }
+    return true;
+  }
+  async _generateImplementationTypings(integrationDef) {
+    const line = this._logger.line();
+    const { name } = integrationDef;
+    line.started(`Generating typings for integration ${import_chalk.default.bold(name)}...`);
+    const { rel } = this._paths;
+    try {
+      const typingFiles = await generator.generateIntegrationImplementationTypings(
+        integrationDef,
+        consts.relativeToOutFolder.implementationTypings
+      );
+      const indexFile = await generator.generateIntegrationIndex(consts.relativeToOutFolder.implementationTypings);
+      const generatedFiles = [...typingFiles, indexFile];
+      await this._writeFilesToOutFolder(generatedFiles);
+      line.success(`Typings available at ${import_chalk.default.grey(rel.outDir)}`);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not generate typings");
+    } finally {
+      line.commit();
+    }
+  }
+  async _uninstallIntegration(instance) {
+    const { abs } = this._paths;
+    try {
+      const instancePath = import_path.default.join(consts.installDir(abs.outDir), instance.dirname);
+      await import_fs.default.promises.rm(instancePath, { recursive: true });
+      await this._generateBotIndex();
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not uninstall integration");
+    }
+  }
+  async _generateIntegrationInstance(integration) {
+    const line = this._logger.line();
+    const { name, version } = integration;
+    line.started(`Installing ${import_chalk.default.bold(name)} v${version}...`);
+    const { rel } = this._paths;
+    try {
+      const instanceFiles = await generator.generateIntegrationInstance(
+        integration,
+        consts.relativeToOutFolder.installDir
+      );
+      await this._writeFilesToOutFolder(instanceFiles);
+      await this._generateBotIndex();
+      line.success(`Installed integration available at ${import_chalk.default.grey(rel.outDir)}`);
+    } catch (thrown) {
+      throw errors.BotpressCLIError.wrap(thrown, "Could not install integration");
+    } finally {
+      line.commit();
+    }
+  }
+  async _generateBotIndex() {
+    const allInstances = await this._listIntegrationInstances();
+    const indexFile = await generator.generateBotIndex(
+      consts.relativeToOutFolder.installDir,
+      allInstances.map((i) => i.dirname)
+    );
+    await this._writeFilesToOutFolder([indexFile]);
+  }
+  async _writeFilesToOutFolder(files) {
+    const { abs } = this._paths;
+    for (const file of files) {
+      const filePath = pathutils.absoluteFrom(abs.outDir, file.path);
+      const dirPath = import_path.default.dirname(filePath);
+      await import_fs.default.promises.mkdir(dirPath, { recursive: true });
+      await import_fs.default.promises.writeFile(filePath, file.content);
+    }
+  }
+  async _readIntegrationDefinitionFromFS() {
+    const { abs, rel } = this._paths;
+    if (!import_fs.default.existsSync(abs.definition)) {
+      this._logger.debug(`Integration definition not found at ${rel.definition}`);
+      return;
+    }
+    const { outputFiles } = await esbuild.buildEntrypoint({
+      cwd: abs.workDir,
+      outfile: "",
+      entrypoint: rel.definition,
+      write: false
+    });
+    const artifact = outputFiles[0];
+    if (!artifact) {
+      throw new errors.BotpressCLIError("Could not read integration definition");
+    }
+    const { default: definition } = requireutils.requireJsCode(artifact.text);
+    return definition;
+  }
+  async _ensureLoginAndCreateClient(argv) {
+    const token = await this._userCache.get("token");
+    const workspaceId = argv.workspaceId ?? await this._userCache.get("workspaceId");
+    const host = argv.host ?? await this._userCache.get("host");
+    if (!(token && workspaceId && host)) {
+      throw new errors.NotLoggedInError();
+    }
+    const client = new bpclient.Client({ host, token, workspaceId });
+    return new import_api_utils.ApiUtils(client, host, token, workspaceId, this._logger);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProjectCommands,
+  ProjectPaths
+});

package/dist/app/typings.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);