skuba 0.0.0-master-20230318044948

package/lib/utils/args.js

@@ -0,0 +1,114 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var args_exports = {};
+__export(args_exports, {
+  hasDebugFlag: () => hasDebugFlag,
+  hasSerialFlag: () => hasSerialFlag,
+  parseProcessArgs: () => parseProcessArgs,
+  parseRunArgs: () => parseRunArgs
+});
+module.exports = __toCommonJS(args_exports);
+var import_assert = __toESM(require("assert"));
+var import_command = require("./command");
+const hasDebugFlag = (args = process.argv) => args.some((arg) => arg.toLocaleLowerCase() === "--debug");
+const hasSerialFlag = (args = process.argv, env = process.env) => args.some((arg) => arg.toLocaleLowerCase() === "--serial") || Boolean(
+  // Run serially on SEEK's central npm publishing pipeline.
+  // Exhausting agents here can cause grief.
+  env.BUILDKITE_AGENT_META_DATA_QUEUE?.split(",").some(
+    (queueName) => queueName.startsWith("artefacts:npm")
+  )
+);
+const parseProcessArgs = (args = process.argv) => {
+  const skubaIdx = args.findIndex((chunk) => /skuba(\.[jt]s)?$/.test(chunk));
+  (0, import_assert.default)(skubaIdx >= 0, "Cannot parse args for `skuba`");
+  const rawCommand = (args[skubaIdx + 1] ?? "help").toLocaleLowerCase();
+  const commandName = import_command.COMMAND_ALIASES[rawCommand] ?? rawCommand;
+  const payload = {
+    commandName,
+    args: args.slice(skubaIdx + 2)
+  };
+  args.splice(skubaIdx + 1, 1);
+  return payload;
+};
+const parseRunArgs = (argv) => {
+  const state = {
+    node: [],
+    script: []
+  };
+  let args = argv.filter((element) => element.length);
+  while (args.length) {
+    args = parseRunArgsIteration(state, args);
+  }
+  return state;
+};
+const isDigits = (arg) => typeof arg === "string" && /^\d+$/.test(arg);
+const parseRunArgsIteration = (state, args) => {
+  const [arg1, arg2] = args;
+  if (!arg1) {
+    return [];
+  }
+  if (/^--inspect(-brk)?=\d+$/.test(arg1)) {
+    state.node.push(arg1);
+    return args.slice(1);
+  }
+  if (["--inspect", "--inspect-brk"].includes(arg1)) {
+    if (isDigits(arg2)) {
+      state.node.push(`${arg1}=${arg2}`);
+      return args.slice(2);
+    }
+    state.node.push(arg1);
+    if (arg2) {
+      state.entryPoint = arg2;
+      state.script.push(...args.slice(2));
+    }
+    return [];
+  }
+  if (/^--port=\d+$/.test(arg1)) {
+    state.port = Number(arg1.slice(7));
+    return args.slice(1);
+  }
+  if (arg1 === "--port") {
+    if (isDigits(arg2)) {
+      state.port = Number(arg2);
+      return args.slice(2);
+    }
+    return args.slice(1);
+  }
+  state.entryPoint = arg1;
+  state.script.push(...args.slice(1));
+  return [];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hasDebugFlag,
+  hasSerialFlag,
+  parseProcessArgs,
+  parseRunArgs
+});
+//# sourceMappingURL=args.js.map

package/lib/utils/args.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/args.ts"],
+  "sourcesContent": ["import assert from 'assert';\n\nimport { COMMAND_ALIASES } from './command';\n\nexport const hasDebugFlag = (args = process.argv) =>\n  args.some((arg) => arg.toLocaleLowerCase() === '--debug');\n\nexport const hasSerialFlag = (args = process.argv, env = process.env) =>\n  args.some((arg) => arg.toLocaleLowerCase() === '--serial') ||\n  Boolean(\n    // Run serially on SEEK's central npm publishing pipeline.\n    // Exhausting agents here can cause grief.\n    env.BUILDKITE_AGENT_META_DATA_QUEUE?.split(',').some((queueName) =>\n      queueName.startsWith('artefacts:npm'),\n    ),\n  );\n\n/**\n * Parse process arguments.\n *\n * This function mutates the input list by removing the command name element.\n * Downstream commands can access their args with an ordinary\n * `process.argv.slice(2)`.\n *\n * Example input:\n *\n * ```typescript\n * ['/bin/node', 'node_modules/.bin/skuba', 'test', '--foo', '--bar']\n * ```\n */\nexport const parseProcessArgs = (args = process.argv) => {\n  const skubaIdx = args.findIndex((chunk) => /skuba(\\.[jt]s)?$/.test(chunk));\n\n  assert(skubaIdx >= 0, 'Cannot parse args for `skuba`');\n\n  const rawCommand = (args[skubaIdx + 1] ?? 'help').toLocaleLowerCase();\n\n  const commandName = COMMAND_ALIASES[rawCommand] ?? rawCommand;\n\n  const payload = {\n    commandName,\n    args: args.slice(skubaIdx + 2),\n  };\n\n  args.splice(skubaIdx + 1, 1);\n\n  return payload;\n};\n\ninterface RunArgs {\n  /** The path to the entry point script. */\n  entryPoint?: string;\n\n  /** The port to start an HTTP server on. */\n  port?: number;\n\n  /** Arguments passed through to the Node.js executable. */\n  node: string[];\n\n  /** Arguments passed through to the entry point script. */\n  script: string[];\n}\n\n/**\n * Make a best effort to parse \"run\" args.\n *\n * These are arguments that would be passed to `skuba node` or `skuba start`.\n * Parsing is handrolled because we support some weird and wonderful behaviour:\n *\n * - The `--port` option may be intended for skuba itself\n * - The `--inspect` options may be intended for the Node.js inspector\n * - The entry point may be omitted in favour of `package.json` inference\n * - Other args may be intended for propagation to the entry point\n */\nexport const parseRunArgs = (argv: string[]): RunArgs => {\n  const state: RunArgs = {\n    node: [],\n    script: [],\n  };\n\n  let args = argv.filter((element) => element.length);\n\n  while (args.length) {\n    args = parseRunArgsIteration(state, args);\n  }\n\n  return state;\n};\n\nconst isDigits = (arg: unknown) => typeof arg === 'string' && /^\\d+$/.test(arg);\n\nconst parseRunArgsIteration = (state: RunArgs, args: string[]): string[] => {\n  const [arg1, arg2] = args;\n\n  if (!arg1) {\n    return [];\n  }\n\n  if (/^--inspect(-brk)?=\\d+$/.test(arg1)) {\n    state.node.push(arg1);\n    return args.slice(1);\n  }\n\n  // Node.js inspector options that are optionally followed by a numeric port.\n  if (['--inspect', '--inspect-brk'].includes(arg1)) {\n    if (isDigits(arg2)) {\n      state.node.push(`${arg1}=${arg2}`);\n      return args.slice(2);\n    }\n\n    state.node.push(arg1);\n\n    if (arg2) {\n      // Some other string that doesn't relate to the Node.js inspector option.\n      // This is presumably the entry point script to run.\n      state.entryPoint = arg2;\n      state.script.push(...args.slice(2));\n    }\n\n    return [];\n  }\n\n  if (/^--port=\\d+$/.test(arg1)) {\n    state.port = Number(arg1.slice(7));\n    return args.slice(1);\n  }\n\n  if (arg1 === '--port') {\n    if (isDigits(arg2)) {\n      state.port = Number(arg2);\n      return args.slice(2);\n    }\n\n    // Invalid port argument; eat it.\n    return args.slice(1);\n  }\n\n  state.entryPoint = arg1;\n  state.script.push(...args.slice(1));\n  return [];\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAmB;AAEnB,qBAAgC;AAEzB,MAAM,eAAe,CAAC,OAAO,QAAQ,SAC1C,KAAK,KAAK,CAAC,QAAQ,IAAI,kBAAkB,MAAM,SAAS;AAEnD,MAAM,gBAAgB,CAAC,OAAO,QAAQ,MAAM,MAAM,QAAQ,QAC/D,KAAK,KAAK,CAAC,QAAQ,IAAI,kBAAkB,MAAM,UAAU,KACzD;AAAA;AAAA;AAAA,EAGE,IAAI,iCAAiC,MAAM,GAAG,EAAE;AAAA,IAAK,CAAC,cACpD,UAAU,WAAW,eAAe;AAAA,EACtC;AACF;AAeK,MAAM,mBAAmB,CAAC,OAAO,QAAQ,SAAS;AACvD,QAAM,WAAW,KAAK,UAAU,CAAC,UAAU,mBAAmB,KAAK,KAAK,CAAC;AAEzE,oBAAAA,SAAO,YAAY,GAAG,+BAA+B;AAErD,QAAM,cAAc,KAAK,WAAW,CAAC,KAAK,QAAQ,kBAAkB;AAEpE,QAAM,cAAc,+BAAgB,UAAU,KAAK;AAEnD,QAAM,UAAU;AAAA,IACd;AAAA,IACA,MAAM,KAAK,MAAM,WAAW,CAAC;AAAA,EAC/B;AAEA,OAAK,OAAO,WAAW,GAAG,CAAC;AAE3B,SAAO;AACT;AA2BO,MAAM,eAAe,CAAC,SAA4B;AACvD,QAAM,QAAiB;AAAA,IACrB,MAAM,CAAC;AAAA,IACP,QAAQ,CAAC;AAAA,EACX;AAEA,MAAI,OAAO,KAAK,OAAO,CAAC,YAAY,QAAQ,MAAM;AAElD,SAAO,KAAK,QAAQ;AAClB,WAAO,sBAAsB,OAAO,IAAI;AAAA,EAC1C;AAEA,SAAO;AACT;AAEA,MAAM,WAAW,CAAC,QAAiB,OAAO,QAAQ,YAAY,QAAQ,KAAK,GAAG;AAE9E,MAAM,wBAAwB,CAAC,OAAgB,SAA6B;AAC1E,QAAM,CAAC,MAAM,IAAI,IAAI;AAErB,MAAI,CAAC,MAAM;AACT,WAAO,CAAC;AAAA,EACV;AAEA,MAAI,yBAAyB,KAAK,IAAI,GAAG;AACvC,UAAM,KAAK,KAAK,IAAI;AACpB,WAAO,KAAK,MAAM,CAAC;AAAA,EACrB;AAGA,MAAI,CAAC,aAAa,eAAe,EAAE,SAAS,IAAI,GAAG;AACjD,QAAI,SAAS,IAAI,GAAG;AAClB,YAAM,KAAK,KAAK,GAAG,QAAQ,MAAM;AACjC,aAAO,KAAK,MAAM,CAAC;AAAA,IACrB;AAEA,UAAM,KAAK,KAAK,IAAI;AAEpB,QAAI,MAAM;AAGR,YAAM,aAAa;AACnB,YAAM,OAAO,KAAK,GAAG,KAAK,MAAM,CAAC,CAAC;AAAA,IACpC;AAEA,WAAO,CAAC;AAAA,EACV;AAEA,MAAI,eAAe,KAAK,IAAI,GAAG;AAC7B,UAAM,OAAO,OAAO,KAAK,MAAM,CAAC,CAAC;AACjC,WAAO,KAAK,MAAM,CAAC;AAAA,EACrB;AAEA,MAAI,SAAS,UAAU;AACrB,QAAI,SAAS,IAAI,GAAG;AAClB,YAAM,OAAO,OAAO,IAAI;AACxB,aAAO,KAAK,MAAM,CAAC;AAAA,IACrB;AAGA,WAAO,KAAK,MAAM,CAAC;AAAA,EACrB;AAEA,QAAM,aAAa;AACnB,QAAM,OAAO,KAAK,GAAG,KAAK,MAAM,CAAC,CAAC;AAClC,SAAO,CAAC;AACV;",
+  "names": ["assert"]
+}

package/lib/utils/command.d.ts

@@ -0,0 +1,6 @@
+export type Command = (typeof COMMAND_LIST)[number];
+export declare const COMMAND_ALIASES: Record<string, Command>;
+export declare const COMMAND_DIR: string;
+export declare const COMMAND_LIST: readonly ["build", "build-package", "configure", "format", "help", "init", "lint", "node", "release", "start", "test", "version"];
+export declare const COMMAND_SET: Set<string>;
+export declare const commandToModule: (command: Command) => string;

package/lib/utils/command.js

@@ -0,0 +1,72 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var command_exports = {};
+__export(command_exports, {
+  COMMAND_ALIASES: () => COMMAND_ALIASES,
+  COMMAND_DIR: () => COMMAND_DIR,
+  COMMAND_LIST: () => COMMAND_LIST,
+  COMMAND_SET: () => COMMAND_SET,
+  commandToModule: () => commandToModule
+});
+module.exports = __toCommonJS(command_exports);
+var import_path = __toESM(require("path"));
+const COMMAND_ALIASES = {
+  "-h": "help",
+  "--help": "help",
+  "-v": "version",
+  "--version": "version"
+};
+const COMMAND_DIR = import_path.default.join(__dirname, "..", "cli");
+const COMMAND_LIST = [
+  "build",
+  "build-package",
+  "configure",
+  "format",
+  "help",
+  "init",
+  "lint",
+  "node",
+  "release",
+  "start",
+  "test",
+  "version"
+];
+const COMMAND_SET = new Set(COMMAND_LIST);
+const commandToModule = (command) => command.split("-").map(
+  (segment, index) => index === 0 ? segment : `${segment[0].toLocaleUpperCase()}${segment.slice(1)}`
+).join("");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COMMAND_ALIASES,
+  COMMAND_DIR,
+  COMMAND_LIST,
+  COMMAND_SET,
+  commandToModule
+});
+//# sourceMappingURL=command.js.map

package/lib/utils/command.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/command.ts"],
+  "sourcesContent": ["import path from 'path';\n\nexport type Command = (typeof COMMAND_LIST)[number];\n\nexport const COMMAND_ALIASES: Record<string, Command> = {\n  '-h': 'help',\n  '--help': 'help',\n  '-v': 'version',\n  '--version': 'version',\n};\n\nexport const COMMAND_DIR = path.join(__dirname, '..', 'cli');\n\nexport const COMMAND_LIST = [\n  'build',\n  'build-package',\n  'configure',\n  'format',\n  'help',\n  'init',\n  'lint',\n  'node',\n  'release',\n  'start',\n  'test',\n  'version',\n] as const;\n\nexport const COMMAND_SET = new Set<string>(COMMAND_LIST);\n\nexport const commandToModule = (command: Command): string =>\n  command\n    .split('-')\n    .map((segment, index) =>\n      index === 0\n        ? segment\n        : `${segment[0].toLocaleUpperCase()}${segment.slice(1)}`,\n    )\n    .join('');\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AAIV,MAAM,kBAA2C;AAAA,EACtD,MAAM;AAAA,EACN,UAAU;AAAA,EACV,MAAM;AAAA,EACN,aAAa;AACf;AAEO,MAAM,cAAc,YAAAA,QAAK,KAAK,WAAW,MAAM,KAAK;AAEpD,MAAM,eAAe;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,MAAM,cAAc,IAAI,IAAY,YAAY;AAEhD,MAAM,kBAAkB,CAAC,YAC9B,QACG,MAAM,GAAG,EACT;AAAA,EAAI,CAAC,SAAS,UACb,UAAU,IACN,UACA,GAAG,QAAQ,CAAC,EAAE,kBAAkB,IAAI,QAAQ,MAAM,CAAC;AACzD,EACC,KAAK,EAAE;",
+  "names": ["path"]
+}

package/lib/utils/copy.d.ts

@@ -0,0 +1,16 @@
+export type TextProcessor = (contents: string) => string;
+interface CopyFilesOptions {
+    sourceRoot: string;
+    destinationRoot: string;
+    include: (pathname: string) => boolean;
+    overwrite?: boolean;
+    processors: Array<TextProcessor>;
+    stripUnderscorePrefix?: boolean;
+}
+export declare const createEjsRenderer: (templateData: Record<string, unknown>) => TextProcessor;
+export declare const createStringReplacer: (replacements: Array<{
+    input: RegExp;
+    output: string;
+}>) => TextProcessor;
+export declare const copyFiles: (opts: CopyFilesOptions, currentSourceDir?: string, currentDestinationDir?: string) => Promise<void>;
+export {};

package/lib/utils/copy.js

@@ -0,0 +1,100 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var copy_exports = {};
+__export(copy_exports, {
+  copyFiles: () => copyFiles,
+  createEjsRenderer: () => createEjsRenderer,
+  createStringReplacer: () => createStringReplacer
+});
+module.exports = __toCommonJS(copy_exports);
+var import_path = __toESM(require("path"));
+var import_ejs = __toESM(require("ejs"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_error = require("./error");
+var import_logging = require("./logging");
+const copyFile = async (sourcePath, destinationPath, { overwrite = true, processors }) => {
+  const oldContents = await import_fs_extra.default.promises.readFile(sourcePath, "utf8");
+  const newContents = processors.reduce(
+    (contents, process) => process(contents),
+    oldContents
+  );
+  if (oldContents === newContents && sourcePath === destinationPath) {
+    return;
+  }
+  try {
+    await import_fs_extra.default.promises.writeFile(destinationPath, newContents, {
+      flag: overwrite ? "w" : "wx"
+    });
+  } catch (err) {
+    if ((0, import_error.isErrorWithCode)(err, "EEXIST")) {
+      return;
+    }
+    throw err;
+  }
+};
+const createEjsRenderer = (templateData) => (contents) => import_ejs.default.render(contents, templateData);
+const createStringReplacer = (replacements) => (contents) => replacements.reduce(
+  (newContents, { input, output }) => newContents.replace(input, output),
+  contents
+);
+const copyFiles = async (opts, currentSourceDir = opts.sourceRoot, currentDestinationDir = opts.destinationRoot) => {
+  const filenames = await import_fs_extra.default.promises.readdir(currentSourceDir);
+  const toDestinationPath = (filename) => import_path.default.join(
+    currentDestinationDir,
+    opts.stripUnderscorePrefix ? filename.replace(/^_\./, ".").replace(/^_package\.json/, "package.json") : filename
+  );
+  const filteredFilenames = filenames.filter(
+    (filename) => opts.include(
+      import_path.default.relative(opts.destinationRoot, toDestinationPath(filename))
+    )
+  );
+  await Promise.all(
+    filteredFilenames.map(async (filename) => {
+      const sourcePath = import_path.default.join(currentSourceDir, filename);
+      const destinationPath = toDestinationPath(filename);
+      try {
+        await copyFile(sourcePath, destinationPath, opts);
+      } catch (err) {
+        if ((0, import_error.isErrorWithCode)(err, "EISDIR")) {
+          await import_fs_extra.default.promises.mkdir(destinationPath, { recursive: true });
+          return copyFiles(opts, sourcePath, destinationPath);
+        }
+        import_logging.log.err("Failed to render", import_logging.log.bold(sourcePath));
+        throw err;
+      }
+    })
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copyFiles,
+  createEjsRenderer,
+  createStringReplacer
+});
+//# sourceMappingURL=copy.js.map

package/lib/utils/copy.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/copy.ts"],
+  "sourcesContent": ["import path from 'path';\n\nimport ejs from 'ejs';\nimport fs from 'fs-extra';\n\nimport { isErrorWithCode } from './error';\nimport { log } from './logging';\n\nexport type TextProcessor = (contents: string) => string;\n\nconst copyFile = async (\n  sourcePath: string,\n  destinationPath: string,\n  { overwrite = true, processors }: CopyFilesOptions,\n) => {\n  const oldContents = await fs.promises.readFile(sourcePath, 'utf8');\n\n  const newContents = processors.reduce(\n    (contents, process) => process(contents),\n    oldContents,\n  );\n\n  if (oldContents === newContents && sourcePath === destinationPath) {\n    return;\n  }\n\n  try {\n    await fs.promises.writeFile(destinationPath, newContents, {\n      flag: overwrite ? 'w' : 'wx',\n    });\n  } catch (err) {\n    if (isErrorWithCode(err, 'EEXIST')) {\n      return;\n    }\n\n    throw err;\n  }\n};\n\ninterface CopyFilesOptions {\n  sourceRoot: string;\n  destinationRoot: string;\n\n  include: (pathname: string) => boolean;\n  overwrite?: boolean;\n  processors: Array<TextProcessor>;\n  stripUnderscorePrefix?: boolean;\n}\n\nexport const createEjsRenderer =\n  (templateData: Record<string, unknown>): TextProcessor =>\n  (contents) =>\n    ejs.render(contents, templateData);\n\nexport const createStringReplacer =\n  (\n    replacements: Array<{\n      input: RegExp;\n      output: string;\n    }>,\n  ): TextProcessor =>\n  (contents) =>\n    replacements.reduce(\n      (newContents, { input, output }) => newContents.replace(input, output),\n      contents,\n    );\n\nexport const copyFiles = async (\n  opts: CopyFilesOptions,\n  currentSourceDir: string = opts.sourceRoot,\n  currentDestinationDir: string = opts.destinationRoot,\n) => {\n  const filenames = await fs.promises.readdir(currentSourceDir);\n\n  const toDestinationPath = (filename: string) =>\n    path.join(\n      currentDestinationDir,\n      opts.stripUnderscorePrefix\n        ? filename\n            .replace(/^_\\./, '.')\n            .replace(/^_package\\.json/, 'package.json')\n        : filename,\n    );\n\n  const filteredFilenames = filenames.filter((filename) =>\n    opts.include(\n      path.relative(opts.destinationRoot, toDestinationPath(filename)),\n    ),\n  );\n\n  await Promise.all(\n    filteredFilenames.map(async (filename) => {\n      const sourcePath = path.join(currentSourceDir, filename);\n      const destinationPath = toDestinationPath(filename);\n\n      try {\n        await copyFile(sourcePath, destinationPath, opts);\n      } catch (err) {\n        if (isErrorWithCode(err, 'EISDIR')) {\n          await fs.promises.mkdir(destinationPath, { recursive: true });\n          return copyFiles(opts, sourcePath, destinationPath);\n        }\n\n        log.err('Failed to render', log.bold(sourcePath));\n\n        throw err;\n      }\n    }),\n  );\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AAEjB,iBAAgB;AAChB,sBAAe;AAEf,mBAAgC;AAChC,qBAAoB;AAIpB,MAAM,WAAW,OACf,YACA,iBACA,EAAE,YAAY,MAAM,WAAW,MAC5B;AACH,QAAM,cAAc,MAAM,gBAAAA,QAAG,SAAS,SAAS,YAAY,MAAM;AAEjE,QAAM,cAAc,WAAW;AAAA,IAC7B,CAAC,UAAU,YAAY,QAAQ,QAAQ;AAAA,IACvC;AAAA,EACF;AAEA,MAAI,gBAAgB,eAAe,eAAe,iBAAiB;AACjE;AAAA,EACF;AAEA,MAAI;AACF,UAAM,gBAAAA,QAAG,SAAS,UAAU,iBAAiB,aAAa;AAAA,MACxD,MAAM,YAAY,MAAM;AAAA,IAC1B,CAAC;AAAA,EACH,SAAS,KAAP;AACA,YAAI,8BAAgB,KAAK,QAAQ,GAAG;AAClC;AAAA,IACF;AAEA,UAAM;AAAA,EACR;AACF;AAYO,MAAM,oBACX,CAAC,iBACD,CAAC,aACC,WAAAC,QAAI,OAAO,UAAU,YAAY;AAE9B,MAAM,uBACX,CACE,iBAKF,CAAC,aACC,aAAa;AAAA,EACX,CAAC,aAAa,EAAE,OAAO,OAAO,MAAM,YAAY,QAAQ,OAAO,MAAM;AAAA,EACrE;AACF;AAEG,MAAM,YAAY,OACvB,MACA,mBAA2B,KAAK,YAChC,wBAAgC,KAAK,oBAClC;AACH,QAAM,YAAY,MAAM,gBAAAD,QAAG,SAAS,QAAQ,gBAAgB;AAE5D,QAAM,oBAAoB,CAAC,aACzB,YAAAE,QAAK;AAAA,IACH;AAAA,IACA,KAAK,wBACD,SACG,QAAQ,QAAQ,GAAG,EACnB,QAAQ,mBAAmB,cAAc,IAC5C;AAAA,EACN;AAEF,QAAM,oBAAoB,UAAU;AAAA,IAAO,CAAC,aAC1C,KAAK;AAAA,MACH,YAAAA,QAAK,SAAS,KAAK,iBAAiB,kBAAkB,QAAQ,CAAC;AAAA,IACjE;AAAA,EACF;AAEA,QAAM,QAAQ;AAAA,IACZ,kBAAkB,IAAI,OAAO,aAAa;AACxC,YAAM,aAAa,YAAAA,QAAK,KAAK,kBAAkB,QAAQ;AACvD,YAAM,kBAAkB,kBAAkB,QAAQ;AAElD,UAAI;AACF,cAAM,SAAS,YAAY,iBAAiB,IAAI;AAAA,MAClD,SAAS,KAAP;AACA,gBAAI,8BAAgB,KAAK,QAAQ,GAAG;AAClC,gBAAM,gBAAAF,QAAG,SAAS,MAAM,iBAAiB,EAAE,WAAW,KAAK,CAAC;AAC5D,iBAAO,UAAU,MAAM,YAAY,eAAe;AAAA,QACpD;AAEA,2BAAI,IAAI,oBAAoB,mBAAI,KAAK,UAAU,CAAC;AAEhD,cAAM;AAAA,MACR;AAAA,IACF,CAAC;AAAA,EACH;AACF;",
+  "names": ["fs", "ejs", "path"]
+}

package/lib/utils/dir.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Build a map that associates each glob pattern with its matching filepaths.
+ */
+export declare const buildPatternToFilepathMap: (patterns: string[], allFilepaths: string[]) => {
+    [k: string]: string[];
+};
+/**
+ * List relative filepaths contained within a directory root.
+ *
+ * This excludes:
+ *
+ * - Patterns in the ignore files specified in `ignoreFilenames`
+ * - `.git` subdirectories
+ * - `node_modules` subdirectories
+ */
+export declare const crawlDirectory: (root: string, ignoreFilename?: string) => Promise<string[]>;
+/**
+ * Create a filter function that excludes filepaths based on ignore files like
+ * `.gitignore` and `.prettierignore`.
+ */
+export declare const createInclusionFilter: (ignoreFilepaths: string[]) => Promise<(pathname: string) => boolean>;

package/lib/utils/dir.js

@@ -0,0 +1,91 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dir_exports = {};
+__export(dir_exports, {
+  buildPatternToFilepathMap: () => buildPatternToFilepathMap,
+  crawlDirectory: () => crawlDirectory,
+  createInclusionFilter: () => createInclusionFilter
+});
+module.exports = __toCommonJS(dir_exports);
+var import_path = __toESM(require("path"));
+var import_fdir = require("fdir");
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_ignore = __toESM(require("ignore"));
+var import_picomatch = __toESM(require("picomatch"));
+var import_error = require("./error");
+const buildPatternToFilepathMap = (patterns, allFilepaths) => Object.fromEntries(
+  patterns.map((pattern) => {
+    const isMatch = (0, import_picomatch.default)(pattern);
+    const filepaths = allFilepaths.filter((filepath) => isMatch(filepath));
+    return [pattern, filepaths];
+  })
+);
+const crawlDirectory = async (root, ignoreFilename = ".gitignore") => {
+  const ignoreFileFilter = await createInclusionFilter([
+    import_path.default.join(root, ignoreFilename)
+  ]);
+  const output = await new import_fdir.fdir().crawlWithOptions(root, {
+    exclude: (dirname) => [".git", "node_modules"].includes(dirname),
+    filters: [
+      (pathname) => {
+        const relativePathname = import_path.default.relative(root, pathname);
+        return ignoreFileFilter(relativePathname);
+      }
+    ],
+    includeBasePath: true
+  }).withPromise();
+  const absoluteFilenames = output;
+  const relativeFilepaths = absoluteFilenames.map(
+    (filepath) => import_path.default.relative(root, filepath)
+  );
+  return relativeFilepaths;
+};
+const createInclusionFilter = async (ignoreFilepaths) => {
+  const ignoreFiles = await Promise.all(
+    ignoreFilepaths.map(async (ignoreFilepath) => {
+      try {
+        return await import_fs_extra.default.promises.readFile(ignoreFilepath, "utf8");
+      } catch (err) {
+        if ((0, import_error.isErrorWithCode)(err, "ENOENT")) {
+          return;
+        }
+        throw err;
+      }
+    })
+  );
+  const managers = ignoreFiles.filter((value) => typeof value === "string").map((value) => (0, import_ignore.default)().add(value));
+  return (0, import_ignore.default)().add(".git").add(managers).createFilter();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPatternToFilepathMap,
+  crawlDirectory,
+  createInclusionFilter
+});
+//# sourceMappingURL=dir.js.map

package/lib/utils/dir.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/dir.ts"],
+  "sourcesContent": ["import path from 'path';\n\nimport { fdir as FDir } from 'fdir';\nimport fs from 'fs-extra';\nimport ignore from 'ignore';\nimport picomatch from 'picomatch';\n\nimport { isErrorWithCode } from './error';\n\n/**\n * Build a map that associates each glob pattern with its matching filepaths.\n */\nexport const buildPatternToFilepathMap = (\n  patterns: string[],\n  allFilepaths: string[],\n) =>\n  Object.fromEntries(\n    patterns.map((pattern) => {\n      const isMatch = picomatch(pattern);\n\n      const filepaths = allFilepaths.filter((filepath) => isMatch(filepath));\n\n      return [pattern, filepaths] as const;\n    }),\n  );\n\n/**\n * List relative filepaths contained within a directory root.\n *\n * This excludes:\n *\n * - Patterns in the ignore files specified in `ignoreFilenames`\n * - `.git` subdirectories\n * - `node_modules` subdirectories\n */\nexport const crawlDirectory = async (\n  root: string,\n  ignoreFilename = '.gitignore',\n) => {\n  const ignoreFileFilter = await createInclusionFilter([\n    path.join(root, ignoreFilename),\n  ]);\n\n  const output = await new FDir()\n    .crawlWithOptions(root, {\n      exclude: (dirname) => ['.git', 'node_modules'].includes(dirname),\n      filters: [\n        (pathname) => {\n          const relativePathname = path.relative(root, pathname);\n\n          return ignoreFileFilter(relativePathname);\n        },\n      ],\n      includeBasePath: true,\n    })\n    .withPromise();\n\n  // Patch over non-specific `fdir` typings.\n  const absoluteFilenames = output as string[];\n\n  const relativeFilepaths = absoluteFilenames.map((filepath) =>\n    path.relative(root, filepath),\n  );\n\n  return relativeFilepaths;\n};\n\n/**\n * Create a filter function that excludes filepaths based on ignore files like\n * `.gitignore` and `.prettierignore`.\n */\nexport const createInclusionFilter = async (ignoreFilepaths: string[]) => {\n  const ignoreFiles = await Promise.all(\n    ignoreFilepaths.map(async (ignoreFilepath) => {\n      try {\n        return await fs.promises.readFile(ignoreFilepath, 'utf8');\n      } catch (err) {\n        if (isErrorWithCode(err, 'ENOENT')) {\n          return;\n        }\n\n        throw err;\n      }\n    }),\n  );\n\n  const managers = ignoreFiles\n    .filter((value): value is string => typeof value === 'string')\n    .map((value) => ignore().add(value));\n\n  return ignore().add('.git').add(managers).createFilter();\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiB;AAEjB,kBAA6B;AAC7B,sBAAe;AACf,oBAAmB;AACnB,uBAAsB;AAEtB,mBAAgC;AAKzB,MAAM,4BAA4B,CACvC,UACA,iBAEA,OAAO;AAAA,EACL,SAAS,IAAI,CAAC,YAAY;AACxB,UAAM,cAAU,iBAAAA,SAAU,OAAO;AAEjC,UAAM,YAAY,aAAa,OAAO,CAAC,aAAa,QAAQ,QAAQ,CAAC;AAErE,WAAO,CAAC,SAAS,SAAS;AAAA,EAC5B,CAAC;AACH;AAWK,MAAM,iBAAiB,OAC5B,MACA,iBAAiB,iBACd;AACH,QAAM,mBAAmB,MAAM,sBAAsB;AAAA,IACnD,YAAAC,QAAK,KAAK,MAAM,cAAc;AAAA,EAChC,CAAC;AAED,QAAM,SAAS,MAAM,IAAI,YAAAC,KAAK,EAC3B,iBAAiB,MAAM;AAAA,IACtB,SAAS,CAAC,YAAY,CAAC,QAAQ,cAAc,EAAE,SAAS,OAAO;AAAA,IAC/D,SAAS;AAAA,MACP,CAAC,aAAa;AACZ,cAAM,mBAAmB,YAAAD,QAAK,SAAS,MAAM,QAAQ;AAErD,eAAO,iBAAiB,gBAAgB;AAAA,MAC1C;AAAA,IACF;AAAA,IACA,iBAAiB;AAAA,EACnB,CAAC,EACA,YAAY;AAGf,QAAM,oBAAoB;AAE1B,QAAM,oBAAoB,kBAAkB;AAAA,IAAI,CAAC,aAC/C,YAAAA,QAAK,SAAS,MAAM,QAAQ;AAAA,EAC9B;AAEA,SAAO;AACT;AAMO,MAAM,wBAAwB,OAAO,oBAA8B;AACxE,QAAM,cAAc,MAAM,QAAQ;AAAA,IAChC,gBAAgB,IAAI,OAAO,mBAAmB;AAC5C,UAAI;AACF,eAAO,MAAM,gBAAAE,QAAG,SAAS,SAAS,gBAAgB,MAAM;AAAA,MAC1D,SAAS,KAAP;AACA,gBAAI,8BAAgB,KAAK,QAAQ,GAAG;AAClC;AAAA,QACF;AAEA,cAAM;AAAA,MACR;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,WAAW,YACd,OAAO,CAAC,UAA2B,OAAO,UAAU,QAAQ,EAC5D,IAAI,CAAC,cAAU,cAAAC,SAAO,EAAE,IAAI,KAAK,CAAC;AAErC,aAAO,cAAAA,SAAO,EAAE,IAAI,MAAM,EAAE,IAAI,QAAQ,EAAE,aAAa;AACzD;",
+  "names": ["picomatch", "path", "FDir", "fs", "ignore"]
+}

package/lib/utils/env.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/**
+ * Whether the code is executing in a CI environment.
+ */
+export declare const isCiEnv: (env?: NodeJS.ProcessEnv) => boolean;

package/lib/utils/env.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var env_exports = {};
+__export(env_exports, {
+  isCiEnv: () => isCiEnv
+});
+module.exports = __toCommonJS(env_exports);
+const isCiEnv = (env = process.env) => Boolean(env.BUILDKITE || env.CI || env.GITHUB_ACTIONS);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isCiEnv
+});
+//# sourceMappingURL=env.js.map

package/lib/utils/env.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/env.ts"],
+  "sourcesContent": ["/**\n * Whether the code is executing in a CI environment.\n */\nexport const isCiEnv = (env = process.env): boolean =>\n  Boolean(env.BUILDKITE || env.CI || env.GITHUB_ACTIONS);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,MAAM,UAAU,CAAC,MAAM,QAAQ,QACpC,QAAQ,IAAI,aAAa,IAAI,MAAM,IAAI,cAAc;",
+  "names": []
+}

package/lib/utils/error.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { inspect } from 'util';
+import * as t from 'runtypes';
+export type ConcurrentlyErrors = t.Static<typeof ConcurrentlyErrors>;
+export declare const ConcurrentlyErrors: t.Array<t.Record<{
+    command: t.Record<{
+        command: t.String;
+        name: t.String;
+    }, false>;
+    index: t.Number;
+    exitCode: t.Number;
+}, false>, false>;
+/**
+ * Creates an error that returns its plain `message` rather than a full stack
+ * trace when `util.inspect`ed.
+ *
+ * This can be useful for terser handling and logging of known error scenarios
+ * that have descriptive messages.
+ *
+ * https://nodejs.org/api/util.html#custom-inspection-functions-on-objects
+ */
+export declare const createTerseError: (message?: string) => Error & {
+    [inspect.custom]: () => string | undefined;
+};
+export declare const handleCliError: (err: unknown) => void;
+export declare const isErrorWithCode: <T>(err: unknown, code: T) => err is Record<PropertyKey, unknown> & {
+    code: T;
+};

package/lib/utils/error.js

@@ -0,0 +1,72 @@
+"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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_exports = {};
+__export(error_exports, {
+  ConcurrentlyErrors: () => ConcurrentlyErrors,
+  createTerseError: () => createTerseError,
+  handleCliError: () => handleCliError,
+  isErrorWithCode: () => isErrorWithCode
+});
+module.exports = __toCommonJS(error_exports);
+var import_util = require("util");
+var t = __toESM(require("runtypes"));
+var import_logging = require("./logging");
+var import_validation = require("./validation");
+const ConcurrentlyErrors = t.Array(
+  t.Record({
+    command: t.Record({
+      command: t.String,
+      name: t.String
+    }),
+    index: t.Number,
+    exitCode: t.Number
+  })
+);
+const createTerseError = (message) => Object.assign(new Error(message), {
+  [import_util.inspect.custom]: () => message
+});
+const isExecaError = (err) => (0, import_validation.hasNumberProp)(err, "exitCode");
+const handleCliError = (err) => {
+  if (isExecaError(err)) {
+    process.exitCode = err.exitCode;
+    return;
+  }
+  import_logging.log.err((0, import_util.inspect)(err));
+  process.exitCode = 1;
+  return;
+};
+const isErrorWithCode = (err, code) => (0, import_validation.hasProp)(err, "code") && err.code === code;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConcurrentlyErrors,
+  createTerseError,
+  handleCliError,
+  isErrorWithCode
+});
+//# sourceMappingURL=error.js.map

package/lib/utils/error.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/error.ts"],
+  "sourcesContent": ["/* eslint-disable new-cap */\n\nimport { inspect } from 'util';\n\nimport type { ExecaError } from 'execa';\nimport * as t from 'runtypes';\n\nimport { log } from './logging';\nimport { hasNumberProp, hasProp } from './validation';\n\nexport type ConcurrentlyErrors = t.Static<typeof ConcurrentlyErrors>;\n\nexport const ConcurrentlyErrors = t.Array(\n  t.Record({\n    command: t.Record({\n      command: t.String,\n      name: t.String,\n    }),\n    index: t.Number,\n    exitCode: t.Number,\n  }),\n);\n\n/**\n * Creates an error that returns its plain `message` rather than a full stack\n * trace when `util.inspect`ed.\n *\n * This can be useful for terser handling and logging of known error scenarios\n * that have descriptive messages.\n *\n * https://nodejs.org/api/util.html#custom-inspection-functions-on-objects\n */\nexport const createTerseError = (message?: string) =>\n  Object.assign(new Error(message), {\n    [inspect.custom]: () => message,\n  });\n\nconst isExecaError = (err: unknown): err is ExecaError =>\n  hasNumberProp(err, 'exitCode');\n\nexport const handleCliError = (err: unknown) => {\n  if (isExecaError(err)) {\n    process.exitCode = err.exitCode;\n    return;\n  }\n\n  log.err(inspect(err));\n  process.exitCode = 1;\n  return;\n};\n\nexport const isErrorWithCode = <T>(\n  err: unknown,\n  code: T,\n): err is Record<PropertyKey, unknown> & { code: T } =>\n  hasProp(err, 'code') && err.code === code;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,kBAAwB;AAGxB,QAAmB;AAEnB,qBAAoB;AACpB,wBAAuC;AAIhC,MAAM,qBAAqB,EAAE;AAAA,EAClC,EAAE,OAAO;AAAA,IACP,SAAS,EAAE,OAAO;AAAA,MAChB,SAAS,EAAE;AAAA,MACX,MAAM,EAAE;AAAA,IACV,CAAC;AAAA,IACD,OAAO,EAAE;AAAA,IACT,UAAU,EAAE;AAAA,EACd,CAAC;AACH;AAWO,MAAM,mBAAmB,CAAC,YAC/B,OAAO,OAAO,IAAI,MAAM,OAAO,GAAG;AAAA,EAChC,CAAC,oBAAQ,MAAM,GAAG,MAAM;AAC1B,CAAC;AAEH,MAAM,eAAe,CAAC,YACpB,iCAAc,KAAK,UAAU;AAExB,MAAM,iBAAiB,CAAC,QAAiB;AAC9C,MAAI,aAAa,GAAG,GAAG;AACrB,YAAQ,WAAW,IAAI;AACvB;AAAA,EACF;AAEA,qBAAI,QAAI,qBAAQ,GAAG,CAAC;AACpB,UAAQ,WAAW;AACnB;AACF;AAEO,MAAM,kBAAkB,CAC7B,KACA,aAEA,2BAAQ,KAAK,MAAM,KAAK,IAAI,SAAS;",
+  "names": []
+}