@kubb/cli 1.15.0-canary.20231112T135054 → 2.0.0-alpha.10

package/README.md

@@ -18,7 +18,7 @@
 </p>
 
 <h4>
-    <a href="https://codesandbox.io/s/github/kubb-project/kubb/tree/main/examples/typescript" target="_blank">View Demo</a>
+    <a href="https://codesandbox.io/s/github/kubb-project/kubb/tree/alpha/examples/typescript" target="_blank">View Demo</a>
     <span> · </span>
       <a href="https://kubb.dev/" target="_blank">Documentation</a>
     <span> · </span>

package/bin/kubb.js

@@ -5,7 +5,7 @@ try {
   })
 } catch (err) {}
 
-import('../dist/index.js').then(({ default: runCLI }) => {
+import('../dist/index.js').then(({ run }) => {
   process.title = 'Kubb'
-  runCLI(process.argv)
+  run(process.argv)
 })

package/dist/index.cjs

@@ -1,21 +1,24 @@
 'use strict';
 
-var pathParser = require('path');
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var path = require('path');
 var core = require('@kubb/core');
 var cac = require('cac');
-var pc3 = require('picocolors');
+var pc2 = require('picocolors');
+var utils = require('@kubb/core/utils');
 var cosmiconfig = require('cosmiconfig');
 var tsNode = require('ts-node');
-var stream = require('stream');
 var PrettyError = require('pretty-error');
 var ora = require('ora');
 var execa = require('execa');
 var stringArgv = require('string-argv');
+var stream = require('stream');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var pathParser__default = /*#__PURE__*/_interopDefault(pathParser);
-var pc3__default = /*#__PURE__*/_interopDefault(pc3);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var pc2__default = /*#__PURE__*/_interopDefault(pc2);
 var tsNode__default = /*#__PURE__*/_interopDefault(tsNode);
 var PrettyError__default = /*#__PURE__*/_interopDefault(PrettyError);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
@@ -29,10 +32,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // package.json
-var version = "1.14.8";
+var version = "2.0.0-alpha.10";
 function isJSONPlugins(plugins) {
   return !!plugins?.some((plugin) => {
-    return typeof plugin?.[0] === "string";
+    return Array.isArray(plugin) && typeof plugin?.at(0) === "string";
   });
 }
 function isObjectPlugins(plugins) {
@@ -40,18 +43,16 @@ function isObjectPlugins(plugins) {
 }
 async function importPlugin(name, options) {
   const packageManager = new core.PackageManager(process.cwd());
-  const importedPlugin = process.env.NODE_ENV === "test" ? await import(name) : await packageManager.import(name, process.cwd());
+  const importedPlugin = process.env.NODE_ENV === "test" ? await import(name) : await packageManager.import(name);
   return importedPlugin?.default ? importedPlugin.default(options) : importedPlugin(options);
 }
 function getPlugins(plugins) {
   if (isObjectPlugins(plugins)) {
-    const promises = Object.keys(plugins).map((name) => {
-      return importPlugin(name, plugins[name]);
-    });
-    return Promise.all(promises);
+    throw new Error("Object plugins are not supported anymore, best to use http://kubb.dev/guide/configure#json");
   }
   if (isJSONPlugins(plugins)) {
-    const promises = plugins.map((plugin) => {
+    const jsonPlugins = plugins;
+    const promises = jsonPlugins.map((plugin) => {
       const [name, options = {}] = plugin;
       return importPlugin(name, options);
     });
@@ -66,12 +67,18 @@ async function getConfig(result, CLIOptions) {
   let kubbUserConfig = Promise.resolve(config);
   if (typeof config === "function") {
     const possiblePromise = config(CLIOptions);
-    if (core.isPromise(possiblePromise)) {
+    if (utils.isPromise(possiblePromise)) {
       kubbUserConfig = possiblePromise;
     }
     kubbUserConfig = Promise.resolve(possiblePromise);
   }
   let JSONConfig = await kubbUserConfig;
+  if (Array.isArray(JSONConfig)) {
+    const promises = JSONConfig.map(async (item) => {
+      return { ...item, plugins: item.plugins ? await getPlugins(item.plugins) : void 0 };
+    });
+    return Promise.all(promises);
+  }
   JSONConfig = {
     ...JSONConfig,
     plugins: JSONConfig.plugins ? await getPlugins(JSONConfig.plugins) : void 0
@@ -136,27 +143,6 @@ async function getCosmiConfig(moduleName2, config) {
   }
   return result;
 }
-var OraWritable = class extends stream.Writable {
-  command;
-  spinner;
-  constructor(spinner2, command, opts) {
-    super(opts);
-    this.command = command;
-    this.spinner = spinner2;
-  }
-  _write(chunk, _encoding, callback2) {
-    this.spinner.suffixText = `
-
-${pc3__default.default.bold(pc3__default.default.blue(this.command))}: ${chunk?.toString()}`;
-    callback2();
-  }
-};
-
-// src/utils/parseHrtimeToSeconds.ts
-function parseHrtimeToSeconds(hrtime) {
-  const seconds = (hrtime[0] + hrtime[1] / 1e9).toFixed(3);
-  return seconds;
-}
 var prettyError = new PrettyError__default.default().skipPackage("commander").skip(function callback(traceLine) {
   const pattern = new RegExp("renderErrors");
   const hasMatch = traceLine?.file?.match(pattern);
@@ -174,84 +160,90 @@ function getErrorCauses(errors) {
     return prev;
   }, []).filter(Boolean);
 }
-function renderErrors(error, { prefixText, logLevel = core.LogLevel.silent }) {
+function renderErrors(error, { logLevel = utils.LogLevel.silent }) {
   if (!error) {
     return "";
   }
-  if (error instanceof core.ParallelPluginError) {
-    return [prefixText, ...error.errors.map((e) => renderErrors(e, { logLevel }))].filter(Boolean).join("\n");
-  }
-  if (logLevel === core.LogLevel.silent) {
+  if (logLevel === utils.LogLevel.silent) {
     prettyError.skipNodeFiles();
     prettyError.skip(function skip() {
       return true;
     });
-    return [prefixText, prettyError.render(error)].filter(Boolean).join("\n");
+    return [prettyError.render(error)].filter(Boolean).join("\n");
   }
   const errors = getErrorCauses([error]);
-  return [prefixText, ...errors].filter(Boolean).join("\n");
+  return errors.filter(Boolean).join("\n");
 }
 var spinner = ora__default.default({
   spinner: "clock"
 });
-async function startWatcher(path, cb) {
+async function startWatcher(path4, cb) {
   const { watch } = await import('chokidar');
   const ignored = ["**/{.git,node_modules}/**"];
-  const watcher = watch(path, {
+  const watcher = watch(path4, {
     ignorePermissionErrors: true,
     ignored
   });
   watcher.on("all", (type, file) => {
-    spinner.succeed(pc3__default.default.yellow(pc3__default.default.bold(`Change detected: ${type} ${file}`)));
+    spinner.succeed(pc2__default.default.yellow(pc2__default.default.bold(`Change detected: ${type} ${file}`)));
     spinner.spinner = "clock";
     try {
-      cb(path);
+      cb(path4);
     } catch (e) {
-      spinner.warn(pc3__default.default.red("Watcher failed"));
+      spinner.warn(pc2__default.default.red("Watcher failed"));
     }
   });
   return;
 }
+
+// src/utils/parseHrtimeToSeconds.ts
+function parseHrtimeToSeconds(hrtime) {
+  const seconds = (hrtime[0] + hrtime[1] / 1e9).toFixed(3);
+  return seconds;
+}
+
+// src/utils/getSummary.ts
 function getSummary({ pluginManager, status, hrstart, config, logLevel }) {
   const logs = [];
   const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(hrstart));
-  const buildStartPlugins = [
-    ...new Set(pluginManager.executed.filter((item) => item.hookName === "buildStart" && item.plugin.name !== "core").map((item) => item.plugin.name))
-  ];
-  const failedPlugins = config.plugins?.filter((plugin) => !buildStartPlugins.includes(plugin.name))?.map((plugin) => plugin.name);
+  const buildStartPlugins = pluginManager.executed.filter((item) => item.hookName === "buildStart" && item.plugin.name !== "core").map((item) => item.plugin.name);
+  const buildEndPlugins = pluginManager.executed.filter((item) => item.hookName === "buildEnd" && item.plugin.name !== "core").map((item) => item.plugin.name);
+  const failedPlugins = config.plugins?.filter((plugin) => !buildEndPlugins.includes(plugin.name))?.map((plugin) => plugin.name);
   const pluginsCount = config.plugins?.length || 0;
   const files = pluginManager.fileManager.files.sort((a, b) => {
-    if (!a.meta?.pluginName || !b.meta?.pluginName) {
+    if (!a.meta?.pluginKey?.[1] || !b.meta?.pluginKey?.[1]) {
       return 0;
     }
-    if (a.meta?.pluginName.length < b.meta?.pluginName.length) {
+    if (a.meta?.pluginKey?.[1]?.length < b.meta?.pluginKey?.[1]?.length) {
       return 1;
     }
-    if (a.meta?.pluginName.length > b.meta?.pluginName.length) {
+    if (a.meta?.pluginKey?.[1]?.length > b.meta?.pluginKey?.[1]?.length) {
       return -1;
     }
     return 0;
   });
   const meta = {
-    plugins: status === "success" ? `${pc3__default.default.green(`${buildStartPlugins.length} successful`)}, ${pluginsCount} total` : `${pc3__default.default.red(`${failedPlugins?.length ?? 1} failed`)}, ${pluginsCount} total`,
-    pluginsFailed: status === "failed" ? failedPlugins?.map((name) => core.randomPicoColour(name))?.join(", ") : void 0,
+    name: config.name,
+    plugins: status === "success" ? `${pc2__default.default.green(`${buildStartPlugins.length} successful`)}, ${pluginsCount} total` : `${pc2__default.default.red(`${failedPlugins?.length ?? 1} failed`)}, ${pluginsCount} total`,
+    pluginsFailed: status === "failed" ? failedPlugins?.map((name) => utils.randomPicoColour(name))?.join(", ") : void 0,
     filesCreated: files.length,
-    time: pc3__default.default.yellow(`${elapsedSeconds}s`),
-    output: pathParser__default.default.resolve(config.root, config.output.path)
+    time: pc2__default.default.yellow(`${elapsedSeconds}s`),
+    output: path__default.default.resolve(config.root, config.output.path)
   };
-  if (logLevel === core.LogLevel.debug) {
-    logs.push(pc3__default.default.bold("\nGenerated files:\n"));
-    logs.push(files.map((file) => `${core.randomPicoColour(file.meta?.pluginName)} ${file.path}`).join("\n"));
+  if (logLevel === utils.LogLevel.debug) {
+    logs.push(pc2__default.default.bold("\nGenerated files:\n"));
+    logs.push(files.map((file) => `${utils.randomPicoColour(JSON.stringify(file.meta?.pluginKey))} ${file.path}`).join("\n"));
   }
   logs.push(
     [
       [`
 `, true],
-      [`  ${pc3__default.default.bold("Plugins:")}      ${meta.plugins}`, true],
-      [`   ${pc3__default.default.dim("Failed:")}      ${meta.pluginsFailed || "none"}`, !!meta.pluginsFailed],
-      [`${pc3__default.default.bold("Generated:")}      ${meta.filesCreated} files`, true],
-      [`     ${pc3__default.default.bold("Time:")}      ${meta.time}`, true],
-      [`   ${pc3__default.default.bold("Output:")}      ${meta.output}`, true],
+      [`     ${pc2__default.default.bold("Name:")}      ${meta.name}`, !!meta.name],
+      [`  ${pc2__default.default.bold("Plugins:")}      ${meta.plugins}`, true],
+      [`   ${pc2__default.default.dim("Failed:")}      ${meta.pluginsFailed || "none"}`, !!meta.pluginsFailed],
+      [`${pc2__default.default.bold("Generated:")}      ${meta.filesCreated} files`, true],
+      [`     ${pc2__default.default.bold("Time:")}      ${meta.time}`, true],
+      [`   ${pc2__default.default.bold("Output:")}      ${meta.output}`, true],
       [`
 `, true]
     ].map((item) => {
@@ -263,6 +255,19 @@ function getSummary({ pluginManager, status, hrstart, config, logLevel }) {
   );
   return logs;
 }
+var OraWritable = class extends stream.Writable {
+  constructor(spinner2, command, opts) {
+    super(opts);
+    this.command = command;
+    this.spinner = spinner2;
+  }
+  _write(chunk, _encoding, callback2) {
+    this.spinner.suffixText = `
+
+${pc2__default.default.bold(pc2__default.default.blue(this.command))}: ${chunk?.toString()}`;
+    callback2();
+  }
+};
 
 // src/generate.ts
 async function executeHooks({ hooks, logLevel }) {
@@ -270,7 +275,7 @@ async function executeHooks({ hooks, logLevel }) {
     return;
   }
   const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done];
-  if (logLevel === core.LogLevel.silent) {
+  if (logLevel === utils.LogLevel.silent) {
     spinner.start(`Executing hooks`);
   }
   const executers = commands.map(async (command) => {
@@ -280,66 +285,66 @@ async function executeHooks({ hooks, logLevel }) {
     if (!cmd) {
       return null;
     }
-    await core.timeout(100);
-    spinner.start(`Executing hook ${logLevel !== "silent" ? pc3__default.default.dim(command) : ""}`);
+    spinner.start(`Executing hook ${logLevel !== "silent" ? pc2__default.default.dim(command) : ""}`);
     const subProcess = await execa.execa(cmd, _args, { detached: true, signal: abortController.signal }).pipeStdout(oraWritable);
     spinner.suffixText = "";
-    if (logLevel === core.LogLevel.silent) {
-      spinner.succeed(`Executing hook ${logLevel !== "silent" ? pc3__default.default.dim(command) : ""}`);
+    if (logLevel === utils.LogLevel.silent) {
+      spinner.succeed(`Executing hook ${logLevel !== "silent" ? pc2__default.default.dim(command) : ""}`);
       console.log(subProcess.stdout);
     }
     oraWritable.destroy();
     return { subProcess, abort: abortController.abort.bind(abortController) };
   }).filter(Boolean);
-  await core.timeout(100);
   await Promise.all(executers);
-  if (logLevel === core.LogLevel.silent) {
+  if (logLevel === utils.LogLevel.silent) {
     spinner.succeed(`Executing hooks`);
   }
 }
-async function generate({ input, config, CLIOptions, logger: logger2 }) {
+async function generate({ input, config, CLIOptions }) {
+  const logger = utils.createLogger({ logLevel: CLIOptions.logLevel || utils.LogLevel.silent, name: config.name, spinner });
+  if (logger.name) {
+    spinner.prefixText = utils.randomPicoColour(logger.name);
+  }
   const hrstart = process.hrtime();
-  if (CLIOptions.logLevel === core.LogLevel.debug) {
+  if (CLIOptions.logLevel === utils.LogLevel.debug) {
     const { performance, PerformanceObserver } = await import('perf_hooks');
     const performanceOpserver = new PerformanceObserver((items) => {
       const message = `${items.getEntries()[0]?.duration.toFixed(0)}ms`;
-      spinner.suffixText = pc3__default.default.yellow(message);
+      spinner.suffixText = pc2__default.default.yellow(message);
       performance.clearMarks();
     });
     performanceOpserver.observe({ type: "measure" });
   }
-  try {
-    const { root: _root, ...userConfig } = config;
-    const logLevel = CLIOptions.logLevel ?? core.LogLevel.silent;
-    const inputPath = input ?? ("path" in userConfig.input ? userConfig.input.path : void 0);
-    spinner.start(`\u{1F680} Building ${logLevel !== "silent" ? pc3__default.default.dim(inputPath) : ""}`);
-    const output = await core.build({
-      config: {
-        root: process.cwd(),
-        ...userConfig,
-        input: inputPath ? {
-          ...userConfig.input,
-          path: inputPath
-        } : userConfig.input,
-        output: {
-          write: true,
-          ...userConfig.output
-        }
-      },
-      logger: logger2
-    });
+  const { root: _root, ...userConfig } = config;
+  const logLevel = logger.logLevel;
+  const inputPath = input ?? ("path" in userConfig.input ? userConfig.input.path : void 0);
+  spinner.start(`\u{1F680} Building ${logLevel !== "silent" ? pc2__default.default.dim(inputPath) : ""}`);
+  const { pluginManager, error } = await core.safeBuild({
+    config: {
+      root: process.cwd(),
+      ...userConfig,
+      input: inputPath ? {
+        ...userConfig.input,
+        path: inputPath
+      } : userConfig.input,
+      output: {
+        write: true,
+        ...userConfig.output
+      }
+    },
+    logger
+  });
+  const summary = getSummary({ pluginManager, config, status: error ? "failed" : "success", hrstart, logLevel: CLIOptions.logLevel });
+  if (error) {
     spinner.suffixText = "";
-    spinner.succeed(`\u{1F680} Build completed ${logLevel !== "silent" ? pc3__default.default.dim(inputPath) : ""}`);
-    await executeHooks({ hooks: config.hooks, logLevel });
-    const summary = getSummary({ pluginManager: output.pluginManager, config, status: "success", hrstart, logLevel: CLIOptions.logLevel });
+    spinner.fail(`\u{1F680} Build failed ${logLevel !== "silent" ? pc2__default.default.dim(inputPath) : ""}`);
     console.log(summary.join(""));
-  } catch (error) {
-    let summary = [];
-    if (error instanceof core.PluginError || error instanceof core.ParallelPluginError) {
-      summary = getSummary({ pluginManager: error.pluginManager, config, status: "failed", hrstart, logLevel: CLIOptions.logLevel });
-    }
-    throw new core.SummaryError("Something went wrong\n", { cause: error, summary });
+    throw error;
   }
+  await executeHooks({ hooks: config.hooks, logLevel });
+  spinner.suffixText = "";
+  spinner.succeed(`\u{1F680} Build completed ${logLevel !== "silent" ? pc2__default.default.dim(inputPath) : ""}`);
+  console.log(summary.join(""));
 }
 var presets = {
   simple: {
@@ -359,7 +364,7 @@ export default defineConfig({
     clean: true,
   },
   hooks: {
-    done: 'echo "\u{1F389} done"',
+    done: ['echo "\u{1F389} done"'],
   },
   plugins: [createSwagger({}), createSwaggerTS({ output: 'models', enumType: 'enum' }), createSwaggerTanstackQuery({ output: './hooks' })],
 })
@@ -367,26 +372,26 @@ export default defineConfig({
     packages: ["@kubb/core", "@kubb/cli", "@kubb/swagger", "@kubb/swagger-ts", "@kubb/swagger-tanstack-query"]
   }
 };
-async function init({ preset = "simple", logLevel = core.LogLevel.silent, packageManager = "pnpm" }) {
+async function init({ preset = "simple", logLevel = utils.LogLevel.silent, packageManager = "pnpm" }) {
   spinner.start("\u{1F4E6} Initializing Kubb");
   const presetMeta = presets[preset];
-  const path = pathParser__default.default.resolve(process.cwd(), "./kubb.config.js");
+  const configPath = path__default.default.resolve(process.cwd(), "./kubb.config.js");
   const installCommand = packageManager === "npm" ? "install" : "add";
-  spinner.start(`\u{1F4C0} Writing \`kubb.config.js\` ${pc3__default.default.dim(path)}`);
-  await core.write(presetMeta["kubb.config"], path);
-  spinner.succeed(`\u{1F4C0} Wrote \`kubb.config.js\` ${pc3__default.default.dim(path)}`);
+  spinner.start(`\u{1F4C0} Writing \`kubb.config.js\` ${pc2__default.default.dim(configPath)}`);
+  await utils.write(presetMeta["kubb.config"], configPath);
+  spinner.succeed(`\u{1F4C0} Wrote \`kubb.config.js\` ${pc2__default.default.dim(configPath)}`);
   const results = await Promise.allSettled([
     execa.$`npm init es6 -y`,
     ...presetMeta.packages.map(async (pack) => {
-      spinner.start(`\u{1F4C0} Installing ${pc3__default.default.dim(pack)}`);
+      spinner.start(`\u{1F4C0} Installing ${pc2__default.default.dim(pack)}`);
       const { stdout } = await execa.$({ preferLocal: false })`${packageManager} ${installCommand} ${pack}`;
-      spinner.succeed(`\u{1F4C0} Installed ${pc3__default.default.dim(pack)}`);
+      spinner.succeed(`\u{1F4C0} Installed ${pc2__default.default.dim(pack)}`);
       return stdout;
     })
   ]);
-  if (logLevel === core.LogLevel.info) {
+  if (logLevel === utils.LogLevel.info) {
     results.forEach((result) => {
-      if (core.isPromiseFulfilledResult(result)) {
+      if (utils.isPromiseFulfilledResult(result)) {
         console.log(result.value);
       }
     });
@@ -397,41 +402,42 @@ async function init({ preset = "simple", logLevel = core.LogLevel.silent, packag
 
 // src/index.ts
 var moduleName = "kubb";
-var logger = core.createLogger(spinner);
 function programCatcher(e, CLIOptions) {
-  const originalError = e;
-  let error = originalError;
-  const summaryError = error instanceof core.SummaryError ? error : void 0;
-  if (summaryError) {
-    error = summaryError.cause;
-  }
-  const message = renderErrors(error, { logLevel: CLIOptions.logLevel, prefixText: pc3__default.default.red(originalError?.message) });
+  const error = e;
+  const message = renderErrors(error, { logLevel: CLIOptions.logLevel });
   if (error instanceof core.Warning) {
-    spinner.warn(pc3__default.default.yellow(error.message));
+    spinner.warn(pc2__default.default.yellow(error.message));
     process.exit(0);
   }
-  if (CLIOptions.logLevel === core.LogLevel.silent) {
-    spinner.fail(message);
-    process.exit(1);
-  }
-  spinner.fail([message, ...summaryError?.summary || []].join("\n"));
+  spinner.fail(message);
   process.exit(1);
 }
 async function generateAction(input, CLIOptions) {
-  spinner.start("\u{1F4BE} Loading config");
+  spinner.start("\u{1F50D} Loading config");
   const result = await getCosmiConfig(moduleName, CLIOptions.config);
-  spinner.succeed(`\u{1F4BE} Config loaded(${pc3__default.default.dim(pathParser__default.default.relative(process.cwd(), result.filepath))})`);
+  spinner.succeed(`\u{1F50D} Config loaded(${pc2__default.default.dim(path__default.default.relative(process.cwd(), result.filepath))})`);
   const config = await getConfig(result, CLIOptions);
-  if (CLIOptions.watch && "path" in config.input) {
-    return startWatcher([input || config.input.path], async (paths) => {
-      await generate({ config, CLIOptions, logger });
-      spinner.spinner = "simpleDotsScrolling";
-      spinner.start(pc3__default.default.yellow(pc3__default.default.bold(`Watching for changes in ${paths.join(" and ")}`)));
-    });
+  if (CLIOptions.watch) {
+    if (Array.isArray(config)) {
+      throw new Error("Cannot use watcher with multiple KubbConfigs(array)");
+    }
+    if (core.isInputPath(config)) {
+      return startWatcher([input || config.input.path], async (paths) => {
+        await generate({ config, CLIOptions });
+        spinner.spinner = "simpleDotsScrolling";
+        spinner.start(pc2__default.default.yellow(pc2__default.default.bold(`Watching for changes in ${paths.join(" and ")}`)));
+      });
+    }
+  }
+  if (Array.isArray(config)) {
+    const promiseManager = new core.PromiseManager();
+    const promises = config.map((item) => () => generate({ input, config: item, CLIOptions }));
+    await promiseManager.run("seq", promises);
+    return;
   }
-  await generate({ input, config, CLIOptions, logger });
+  await generate({ input, config, CLIOptions });
 }
-async function runCLI(argv) {
+async function run(argv) {
   const program = cac.cac(moduleName);
   program.command("[input]", "Path of the input file(overrides the one in `kubb.config.js`)").action(generateAction);
   program.command("generate [input]", "Path of the input file(overrides the one in `kubb.config.js`)").option("-c, --config <path>", "Path to the Kubb config").option("-l, --log-level <type>", "Info, silent or debug").option("-w, --watch", "Watch mode based on the input file").action(generateAction);
@@ -448,7 +454,9 @@ async function runCLI(argv) {
     programCatcher(e, program.options);
   }
 }
+var src_default = run;
 
-module.exports = runCLI;
+exports.default = src_default;
+exports.run = run;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.cjs.map