@kaynooo/pkg-tools 0.0.0-stage → 0.3.0

package/dist/cli.js

@@ -0,0 +1,2022 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-mtetydvc.js
+function x(s) {
+  let r = s.startsWith("#") ? s.slice(1).toLowerCase() : s.toLowerCase();
+  if (!/^[a-f0-9]+$/.test(r))
+    return [0, 0, 0];
+  let t = r.length, n = (c) => Number.parseInt(c, 16);
+  if (t === 3 || t === 4) {
+    let c = n(r[0] + r[0]), u = n(r[1] + r[1]), h = n(r[2] + r[2]), g = t === 4 ? n(r[3] + r[3]) : undefined;
+    return g !== undefined ? [c, u, h, g] : [c, u, h];
+  }
+  if (t !== 6 && t !== 8)
+    throw Error(`Invalid hex color length: ${t}`);
+  let a = n(r.slice(0, 2)), b = n(r.slice(2, 4)), o = n(r.slice(4, 6)), y = t === 8 ? n(r.slice(6, 8)) : undefined;
+  if ([a, b, o].some(Number.isNaN) || y !== undefined && Number.isNaN(y))
+    throw Error(`Invalid hex color value: ${s}`);
+  return y !== undefined ? [a, b, o, y] : [a, b, o];
+}
+function A(s) {
+  let [r, t, n, a] = s;
+  if (a)
+    return `#${(r << 24 | t << 16 | n << 8 | Math.round((a ?? 1) * 255)).toString(16).padStart(8, "0").toUpperCase()}`;
+  return `#${(r << 16 | t << 8 | n).toString(16).padStart(6, "0").toUpperCase()}`;
+}
+function R(s, r, t) {
+  s = (s % 360 + 360) % 360, t /= 100;
+  let n = r * Math.min(t, 1 - t) / 100, a = (b) => {
+    let o = (b + s / 30) % 12, y = t - n * Math.max(Math.min(o - 3, 9 - o, 1), -1);
+    return Math.round(255 * y);
+  };
+  return [a(0), a(8), a(4)];
+}
+function k(s) {
+  let [r, t, n] = s;
+  r /= 255, t /= 255, n /= 255;
+  let a = Math.max(r, t, n), b = Math.min(r, t, n), o = 0, y = 0, c = (a + b) / 2;
+  if (a !== b) {
+    let u = a - b;
+    if (y = c > 0 && c < 1 ? u / (1 - Math.abs(2 * c - 1)) : 0, a === r)
+      o = (t - n) / u + (t < n ? 6 : 0);
+    else if (a === t)
+      o = (n - r) / u + 2;
+    else
+      o = (r - t) / u + 4;
+    o /= 6;
+  }
+  return [Math.round(o * 360), Math.round(y * 100), Math.round(c * 100)];
+}
+function H(s, r, t) {
+  s = (s % 360 + 360) % 360, r /= 100, t /= 100;
+  let n = (a) => {
+    let b = (a + s / 60) % 6, o = t - t * r * Math.max(Math.min(b, 4 - b, 1), 0);
+    return Math.round(255 * o);
+  };
+  return [n(5), n(3), n(1)];
+}
+function f(s) {
+  let [r, t, n] = s;
+  r /= 255, t /= 255, n /= 255;
+  let a = Math.max(r, t, n), b = Math.min(r, t, n), o = a - b, y = 0, c = a === 0 ? 0 : o / a, u = a;
+  if (o !== 0) {
+    if (a === r)
+      y = (t - n) / o + (t < n ? 6 : 0);
+    else if (a === t)
+      y = (n - r) / o + 2;
+    else
+      y = (r - t) / o + 4;
+    y /= 6;
+  }
+  return [Math.round(y * 360), Math.round(c * 100), Math.round(u * 100)];
+}
+function O(s) {
+  let r = s[0] / 255, t = s[1] / 255, n = s[2] / 255, a = 1 - Math.max(r, t, n);
+  if (a === 1)
+    return [0, 0, 0, 100];
+  let b = (1 - r - a) / (1 - a), o = (1 - t - a) / (1 - a), y = (1 - n - a) / (1 - a);
+  return [Math.round(b * 100), Math.round(o * 100), Math.round(y * 100), Math.round(a * 100)];
+}
+function v(s, r, t, n) {
+  return s /= 100, r /= 100, t /= 100, n /= 100, [Math.round(255 * (1 - s) * (1 - n)), Math.round(255 * (1 - r) * (1 - n)), Math.round(255 * (1 - t) * (1 - n))];
+}
+function T(s) {
+  let r = m(s[0] / 255), t = m(s[1] / 255), n = m(s[2] / 255), a = Math.cbrt(0.4122214708 * r + 0.5363325363 * t + 0.0514459929 * n), b = Math.cbrt(0.2119034982 * r + 0.6806995451 * t + 0.1073969566 * n), o = Math.cbrt(0.0883024619 * r + 0.2817188376 * t + 0.6299787005 * n);
+  return [i(0.2104542553 * a + 0.793617785 * b - 0.0040720468 * o, 4), i(1.9779984951 * a - 2.428592205 * b + 0.4505937099 * o, 4), i(0.0259040371 * a + 0.7827717662 * b - 0.808675766 * o, 4)];
+}
+function M(s, r, t) {
+  let n = (s + 0.3963377774 * r + 0.2158037573 * t) ** 3, a = (s - 0.1055613458 * r - 0.0638541728 * t) ** 3, b = (s - 0.0894841775 * r - 1.291485548 * t) ** 3, o = p(4.0767416621 * n - 3.3077115913 * a + 0.2309699292 * b), y = p(-1.2684380046 * n + 2.6097574011 * a - 0.3413193965 * b), c = p(-0.0041960863 * n - 0.7034186147 * a + 1.707614701 * b), u = (h) => Math.min(255, Math.max(0, Math.round(h * 255)));
+  return [u(o), u(y), u(c)];
+}
+function d(s) {
+  let [r, t, n] = T(s), a = Math.sqrt(t * t + n * n), b = (Math.atan2(n, t) * 180 / Math.PI + 360) % 360;
+  return [i(r, 4), i(a, 4), i(b, 2)];
+}
+function C(s, r, t) {
+  let n = t * Math.PI / 180;
+  return M(s, r * Math.cos(n), r * Math.sin(n));
+}
+function l(s) {
+  let r = s / 255;
+  return r <= 0.03928 ? r / 12.92 : ((r + 0.055) / 1.055) ** 2.4;
+}
+
+class e {
+  r;
+  g;
+  b;
+  a;
+  constructor(s, r, t, n = 1) {
+    this.r = s, this.g = r, this.b = t, this.a = n;
+  }
+  static from(s, r) {
+    if (s === "hex") {
+      let [t, n, a, b] = x(r);
+      return new e(t, n, a, b);
+    }
+    if (s === "rgb") {
+      if (Array.isArray(r)) {
+        let [o, y, c, u] = r;
+        return new e(o, y, c, u);
+      }
+      let { r: t, g: n, b: a, a: b } = r;
+      return new e(t, n, a, b);
+    }
+    if (s === "hsl") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ h: t, s: n, l: a, a: b } = r);
+      let [o, y, c] = R(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "hsv") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ h: t, s: n, v: a, a: b } = r);
+      let [o, y, c] = H(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "cmyk") {
+      let t, n, a, b, o;
+      if (Array.isArray(r))
+        [t, n, a, b, o] = r;
+      else
+        ({ c: t, m: n, y: a, k: b, a: o } = r);
+      let [y, c, u] = v(t, n, a, b);
+      return new e(y, c, u, o);
+    }
+    if (s === "oklch") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ l: t, c: n, h: a, a: b } = r);
+      let [o, y, c] = C(t, n, a);
+      return new e(o, y, c, b);
+    }
+    if (s === "oklab") {
+      let t, n, a, b;
+      if (Array.isArray(r))
+        [t, n, a, b] = r;
+      else
+        ({ l: t, a: n, b: a, alpha: b } = r);
+      let [o, y, c] = M(t, n, a);
+      return new e(o, y, c, b);
+    }
+    throw Error("Invalid input");
+  }
+  to(s) {
+    switch (s) {
+      case "rgb":
+        return [this.r, this.g, this.b];
+      case "rgba":
+        return [this.r, this.g, this.b, this.a];
+      case "hex":
+        return A([this.r, this.g, this.b]);
+      case "hexa":
+        return A([this.r, this.g, this.b, this.a]);
+      case "hsl":
+        return k([this.r, this.g, this.b]);
+      case "hsla":
+        return [...k([this.r, this.g, this.b]), this.a];
+      case "hsv":
+        return f([this.r, this.g, this.b]);
+      case "hsva":
+        return [...f([this.r, this.g, this.b]), this.a];
+      case "cmyk":
+        return O([this.r, this.g, this.b]);
+      case "cmyka":
+        return [...O([this.r, this.g, this.b]), this.a];
+      case "oklch":
+        return d([this.r, this.g, this.b]);
+      case "oklcha":
+        return [...d([this.r, this.g, this.b]), this.a];
+      case "oklab":
+        return T([this.r, this.g, this.b]);
+      case "oklaba":
+        return [...T([this.r, this.g, this.b]), this.a];
+      default:
+        return [this.r, this.g, this.b];
+    }
+  }
+  getLuminance() {
+    let s = l(this.r), r = l(this.g), t = l(this.b);
+    return 0.2126 * s + 0.7152 * r + 0.0722 * t;
+  }
+  contrastRatio(s) {
+    let r = this.getLuminance(), t = s.getLuminance(), [n, a] = r >= t ? [r, t] : [t, r];
+    return (n + 0.05) / (a + 0.05);
+  }
+  bestContrastForeground() {
+    let s = new e(255, 255, 255, 1), r = new e(0, 0, 0, 1), t = this.contrastRatio(s), n = this.contrastRatio(r);
+    return t >= n ? s : r;
+  }
+}
+var m = (s) => s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4, p = (s) => s <= 0.0031308 ? 12.92 * s : 1.055 * s ** 0.4166666666666667 - 0.055, i = (s, r) => Math.round(s * 10 ** r) / 10 ** r;
+var init_chunk_mtetydvc = () => {};
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-y1msbssb.js
+function h(i, n = globalThis.process?.env ?? {}) {
+  if (n.FORCE_COLOR !== undefined)
+    return b.has(n.FORCE_COLOR);
+  if (n.NO_COLOR !== undefined || n.NODE_DISABLE_COLORS !== undefined || n.TERM === "dumb")
+    return false;
+  return i?.isTTY === true;
+}
+function d2(i, n, a) {
+  if (!h(a.stream ?? globalThis.process?.stdout, a.env))
+    return n;
+  let l = "", s = "";
+  for (let g = 0, y = i.length;g < y; g++) {
+    let [c, p] = i[g];
+    l += `${f2}${c}m`, s = `${f2}${p}m${s}`;
+  }
+  return l + n + s;
+}
+function u(i, n = []) {
+  return new Proxy((l) => d2(n, l, i), { get(l, s) {
+    let g = C2[s];
+    if (Array.isArray(g))
+      return u(i, [...n, g]);
+    if (typeof g === "function")
+      return (...y) => u(i, [...n, g(...y)]);
+    throw Error(`Unknown style: ${String(s)}`);
+  } });
+}
+function le(i = {}) {
+  return u(i);
+}
+var r = 39, o = 49, f2 = "\x1B[", C2, b, t;
+var init_chunk_y1msbssb = __esm(() => {
+  init_chunk_mtetydvc();
+  C2 = { reset: [0, 0], bold: [1, 22], dim: [2, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], hidden: [8, 28], strikethrough: [9, 29], black: [30, r], red: [31, r], green: [32, r], yellow: [33, r], blue: [34, r], magenta: [35, r], cyan: [36, r], white: [37, r], gray: [90, r], grey: [90, r], blackBright: [90, r], redBright: [91, r], greenBright: [92, r], yellowBright: [93, r], blueBright: [94, r], magentaBright: [95, r], cyanBright: [96, r], whiteBright: [97, r], bgBlack: [40, o], bgRed: [41, o], bgGreen: [42, o], bgYellow: [43, o], bgBlue: [44, o], bgMagenta: [45, o], bgCyan: [46, o], bgWhite: [47, o], bgBlackBright: [100, o], bgRedBright: [101, o], bgGreenBright: [102, o], bgYellowBright: [103, o], bgBlueBright: [104, o], bgMagentaBright: [105, o], bgCyanBright: [106, o], bgWhiteBright: [107, o], rgb: (i, n, a, l = "fg") => [`${l === "fg" ? 38 : 48};2;${i};${n};${a}`, l === "fg" ? r : o], hex: (i, n = "fg") => {
+    let [a, l, s] = e.from("hex", i).to("rgb");
+    return [`${n === "fg" ? 38 : 48};2;${a};${l};${s}`, n === "fg" ? r : o];
+  }, ansi256: (i, n = "fg") => [`${n === "fg" ? 38 : 48};5;${i}`, n === "fg" ? r : o] };
+  b = new Set(["", "1", "2", "3", "true"]);
+  t = le();
+});
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/tools/colors.js
+var init_colors = __esm(() => {
+  init_chunk_y1msbssb();
+});
+
+// ../kit/src/style.ts
+import process from "process";
+function takesControlCodes(stream, env = process.env) {
+  return stream.isTTY === true && env.NO_COLOR === undefined && env.NODE_DISABLE_COLORS === undefined && env.TERM !== "dumb";
+}
+function paint(stream, env = process.env) {
+  return le({ stream: { isTTY: takesControlCodes(stream, env) }, env });
+}
+function marked(mark, text, stream, detail, env = process.env) {
+  const colors = paint(stream, env);
+  const { symbol, word, paint: tint } = MARKS[mark];
+  const head = takesControlCodes(stream, env) ? tint(colors)(symbol) : word;
+  return `${head} ${text}${detail === undefined ? "" : ` ${colors.dim(detail)}`}`;
+}
+function ok(text, detail) {
+  console.log(marked("ok", text, process.stdout, detail));
+}
+function note(text, detail) {
+  console.log(marked("note", text, process.stdout, detail));
+}
+function warn(text, detail) {
+  console.error(marked("warn", text, process.stderr, detail));
+}
+function problem(text, detail) {
+  console.error(marked("problem", text, process.stderr, detail));
+}
+var MARKS, STATUSES, STATUS_OF;
+var init_style = __esm(() => {
+  init_colors();
+  MARKS = {
+    ok: { symbol: "\u2713", word: "ok:", paint: (colors) => colors.green },
+    warn: { symbol: "!", word: "warning:", paint: (colors) => colors.yellow },
+    problem: { symbol: "\u2717", word: "error:", paint: (colors) => colors.red },
+    note: { symbol: "\xB7", word: "note:", paint: (colors) => colors.dim }
+  };
+  STATUSES = {
+    passed: { symbol: "\u2713", words: ["passed", "success", "succeeded", "ok"], paint: (colors) => colors.green },
+    failed: { symbol: "\u2717", words: ["failed", "failure", "error", "errored"], paint: (colors) => colors.red },
+    running: { symbol: "\u25CF", words: ["running", "in_progress", "started"], paint: (colors) => colors.cyan },
+    queued: { symbol: "\u25CB", words: ["queued", "waiting", "pending", "created", "blocked", "scheduled"], paint: (colors) => colors.yellow },
+    skipped: { symbol: "-", words: ["skipped", "cancelled", "canceled", "manual"], paint: (colors) => colors.dim }
+  };
+  STATUS_OF = new Map(Object.entries(STATUSES).flatMap(([status, { words }]) => words.map((word) => [word, status])));
+});
+
+// ../kit/src/format.ts
+import process2 from "process";
+function formatSeconds(total) {
+  let rest = Math.max(0, Math.round(total));
+  const amounts = UNITS.map(([unit, size]) => {
+    const amount = Math.floor(rest / size);
+    rest -= amount * size;
+    return `${amount}${unit}`;
+  });
+  const first = amounts.findIndex((amount) => !amount.startsWith("0"));
+  if (first === -1)
+    return "0s";
+  const next = amounts[first + 1];
+  return next === undefined || next.startsWith("0") ? amounts[first] ?? "0s" : `${amounts[first]} ${next}`;
+}
+function formatDuration(ms) {
+  return ms < 60000 ? `${(Math.max(0, ms) / 1000).toFixed(1)}s` : formatSeconds(ms / 1000);
+}
+function upTo(text, separator) {
+  const end = text.indexOf(separator);
+  return end === -1 ? text : text.slice(0, end);
+}
+function formatAge(date, now = Date.now()) {
+  const at = typeof date === "number" ? date : Date.parse(date);
+  if (Number.isNaN(at))
+    return "-";
+  const seconds = (now - at) / 1000;
+  return seconds < 60 ? "just now" : `${upTo(formatSeconds(seconds), " ")} ago`;
+}
+function truncate(text, width) {
+  return text.length <= width ? text : `${text.slice(0, Math.max(0, width - 1))}\u2026`;
+}
+function textWidth(text) {
+  return Bun.stringWidth(text);
+}
+function table(rows, { cellWidth, header = false, align = [], fit } = {}) {
+  const cells = cellWidth === undefined ? rows : rows.map((row) => row.map((cell) => truncate(cell.replaceAll(LINE_BREAKS, " "), cellWidth)));
+  const widths = [];
+  for (const row of cells) {
+    for (const [index, cell] of row.entries())
+      widths[index] = Math.max(widths[index] ?? 0, textWidth(cell));
+  }
+  const shown = fit === undefined ? cells : narrow(cells, widths, fit);
+  const colors = paint(process2.stdout);
+  const lines = shown.map((row) => row.map((cell, index) => {
+    const width = widths[index] ?? 0;
+    const gap = " ".repeat(Math.max(0, width - textWidth(cell)));
+    if (align[index] === "right")
+      return `${gap}${cell}`;
+    return index === row.length - 1 ? cell : `${cell}${gap}`;
+  }).join("  ").trimEnd());
+  return lines.map((line, index) => header && index === 0 ? colors.bold(line) : line).join(`
+`);
+}
+function narrow(rows, widths, limit) {
+  const used = () => widths.reduce((sum, width) => sum + width, 0) + 2 * Math.max(0, widths.length - 1);
+  const cuttable = (index) => rows.every((row) => !(row[index] ?? "").includes(ESCAPE));
+  const floor = 8;
+  while (used() > limit) {
+    let widest = -1;
+    for (const [index, width] of widths.entries()) {
+      if (cuttable(index) && width > floor && width > (widths[widest] ?? 0))
+        widest = index;
+    }
+    if (widest === -1)
+      break;
+    widths[widest] = Math.max(floor, (widths[widest] ?? 0) - (used() - limit));
+  }
+  return rows.map((row) => row.map((cell, index) => textWidth(cell) > (widths[index] ?? 0) ? truncate(cell, widths[index] ?? 0) : cell));
+}
+function printJson(value) {
+  console.log(JSON.stringify(value, undefined, 2));
+}
+var UNITS, LINE_BREAKS, ESCAPE;
+var init_format = __esm(() => {
+  init_style();
+  UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
+  LINE_BREAKS = /\s*\n\s*/g;
+  ESCAPE = String.fromCharCode(27);
+});
+
+// ../kit/src/args.ts
+import process3 from "process";
+import { parseArgs } from "util";
+function jsonOption(holds) {
+  return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
+}
+function fail(message, code = 2, hint) {
+  throw new Exit(message, code, hint);
+}
+function badUsage(message) {
+  throw new UsageError(message);
+}
+
+class Completing {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+}
+function usageLine(usage, colors = paint(process3.stdout)) {
+  return `${colors.bold("Usage:")} ${usage.replace(USAGE_PREFIX, "").replaceAll(OPTIONAL, (part) => colors.dim(part))}`;
+}
+function helpText(usage, options, colors = paint(process3.stdout), examples = []) {
+  return [usageLine(usage, colors), "", colors.bold("Options:"), ...optionRows(options, colors), ...exampleRows(examples, colors)].join(`
+`);
+}
+function exampleRows(examples, colors = paint(process3.stdout)) {
+  if (examples.length === 0)
+    return [];
+  return ["", colors.bold("Examples:"), ...examples.map((example) => typeof example === "string" ? `  ${example}` : `  ${example[0]}  ${colors.dim(`# ${example[1]}`)}`)];
+}
+function optionRows(options, colors = paint(process3.stdout)) {
+  const rows = Object.entries(options).map(([name, option]) => {
+    const short = option.short === undefined ? "    " : `${colors.cyan(`-${option.short}`)}, `;
+    const value = option.type === "string" ? ` ${colors.dim("<value>")}` : "";
+    return { flag: `${short}${colors.cyan(`--${name}`)}${value}`, width: `-x, --${name}`.length + (option.type === "string" ? " <value>".length : 0), description: option.description };
+  });
+  const width = Math.max(0, ...rows.map((row) => row.width));
+  return rows.map((row) => `  ${row.flag}${" ".repeat(width - row.width)}  ${colors.dim(row.description)}`);
+}
+function applyOutput(color, plain, env = process3.env) {
+  const when = plain === true ? "never" : color ?? "auto";
+  if (when === "auto")
+    return;
+  if (when !== "always" && when !== "never")
+    badUsage(`--color takes auto, always or never, not ${when}`);
+  if (when === "always") {
+    env.FORCE_COLOR = "1";
+    delete env.NO_COLOR;
+  } else {
+    env.NO_COLOR = "1";
+    delete env.FORCE_COLOR;
+  }
+}
+function parse(args, usage, options, settings = {}) {
+  const output = Object.fromEntries(Object.entries(OUTPUT_OPTIONS).filter(([name]) => !(name in options)));
+  const all = { ...options, ...output, help: { type: "boolean", short: "h", description: "show this help" } };
+  if (completion.active)
+    throw new Completing(all);
+  const separator = settings.rest === true ? args.indexOf("--") : -1;
+  const own = separator === -1 ? args : args.slice(0, separator);
+  const rest = separator === -1 ? undefined : args.slice(separator + 1);
+  let parsed;
+  try {
+    parsed = parseArgs({ args: own, options: all, allowPositionals: true, allowNegative: settings.allowNegative === true, strict: true });
+  } catch (error) {
+    badUsage(parseError(error));
+  }
+  const values = parsed.values;
+  applyOutput("color" in output ? values.color : undefined, "plain" in output ? values.plain : undefined);
+  if (values.help === true) {
+    console.log(helpText(usage, all, undefined, settings.examples));
+    throw new HelpShown;
+  }
+  if (settings.positionals !== undefined)
+    checkPositionals(parsed.positionals, settings.positionals);
+  return { ...parsed, positionals: parsed.positionals, rest };
+}
+function checkPositionals(given, names) {
+  const variadic = names.at(-1)?.replace("]", "").endsWith("...") === true;
+  const required = names.filter((name) => !name.startsWith("[")).length;
+  if (given.length < required)
+    badUsage(`missing ${names[given.length]}`);
+  if (!variadic && given.length > names.length)
+    badUsage(`unexpected argument ${given[names.length]}`);
+}
+function parseError(error) {
+  const message = upTo(error instanceof Error ? error.message : String(error), ". ");
+  return `${message.charAt(0).toLowerCase()}${message.slice(1)}`;
+}
+function wholeNumber(value, name, fallback, min = 1) {
+  if (value === undefined)
+    return fallback;
+  const number = Number(value);
+  if (!Number.isInteger(number) || number < min)
+    badUsage(`--${name} takes a whole number from ${min}, not ${value}`);
+  return number;
+}
+function duration(value, name, fallback, unit = "s") {
+  if (value === undefined)
+    return fallback;
+  const match = DURATION.exec(value.trim());
+  const ms = match === null ? 0 : Number(match[1]) * UNIT_MS[match[2] ?? unit];
+  if (ms < 1)
+    badUsage(`--${name} takes a duration such as 30s, 5m or 1h, not ${value}`);
+  return ms;
+}
+var Exit, UsageError, HelpShown, completion, OPTIONAL, USAGE_PREFIX, OUTPUT_OPTIONS, DURATION, UNIT_MS;
+var init_args = __esm(() => {
+  init_format();
+  init_style();
+  Exit = class Exit extends Error {
+    code;
+    hint;
+    constructor(message, code, hint) {
+      super(message);
+      this.code = code;
+      this.hint = hint;
+    }
+  };
+  UsageError = class UsageError extends Exit {
+    constructor(message) {
+      super(message, 2);
+    }
+  };
+  HelpShown = class HelpShown extends Exit {
+    constructor() {
+      super("help shown", 0);
+    }
+  };
+  completion = { active: false };
+  OPTIONAL = /\[[^\]]+\]/g;
+  USAGE_PREFIX = /^usage:\s*/i;
+  OUTPUT_OPTIONS = {
+    color: { type: "string", description: "auto (on a terminal alone), always or never" },
+    plain: { type: "boolean", description: "plain text, no colour or spinner: --color never" }
+  };
+  DURATION = /^(\d+(?:\.\d+)?)(ms|[smh])?$/;
+  UNIT_MS = { ms: 1, s: 1000, m: 60000, h: 3600000 };
+});
+
+// ../kit/src/chart.ts
+var init_chart = __esm(() => {
+  init_format();
+  init_style();
+});
+
+// ../kit/src/text.ts
+function distance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (const [i, left] of [...a].entries()) {
+    const current = [i + 1];
+    for (const [j, right] of [...b].entries())
+      current.push(Math.min((previous[j + 1] ?? 0) + 1, (current[j] ?? 0) + 1, (previous[j] ?? 0) + (left === right ? 0 : 1)));
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+var ANSI;
+var init_text = __esm(() => {
+  ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
+});
+
+// ../kit/src/cli.ts
+import process4 from "process";
+function commandRows(commands, colors) {
+  const width = Math.max(...Object.keys(commands).map((name) => name.length));
+  const groups = new Map([["Commands:", []]]);
+  for (const [name, { summary, group }] of Object.entries(commands)) {
+    const heading = group === undefined ? "Commands:" : `${group}:`;
+    const rows = groups.get(heading) ?? [];
+    rows.push(`  ${colors.cyan(name.padEnd(width))}  ${colors.dim(summary)}`);
+    groups.set(heading, rows);
+  }
+  return [...groups].filter(([, rows]) => rows.length > 0).flatMap(([heading, rows], index) => [...index === 0 ? [] : [""], colors.bold(heading), ...rows]);
+}
+function takeOutputFlags(argv) {
+  let index = 0;
+  for (;index < argv.length; index++) {
+    const word = argv[index];
+    if (word === "--plain")
+      applyOutput(undefined, true);
+    else if (word.startsWith("--color="))
+      applyOutput(word.slice("--color=".length), undefined);
+    else if (word === "--color" && argv[index + 1] !== undefined)
+      applyOutput(argv[++index], undefined);
+    else
+      break;
+  }
+  return argv.slice(index);
+}
+function closest(name, names) {
+  const started = names.find((known) => known.startsWith(name));
+  if (started !== undefined)
+    return started;
+  const [best] = names.map((known) => ({ known, far: distance(name, known) })).sort((a, b) => a.far - b.far);
+  return best !== undefined && best.far <= (name.length < 4 ? 1 : 2) ? best.known : undefined;
+}
+async function help({ path, header, commands, defaultCommand, examples }, stream) {
+  const colors = paint(stream);
+  const prefix = path.join(" ");
+  const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
+  const options = fallback !== undefined && "run" in fallback ? await optionsOf(fallback.run) : undefined;
+  const own = Object.entries(options ?? {}).filter(([name]) => !(name in TOP_OPTIONS));
+  return [
+    header(colors),
+    "",
+    usageLine(`${prefix} ${defaultCommand === undefined ? colors.cyan("<command>") : `[${colors.cyan("<command>")}]`} [options]`, colors),
+    "",
+    ...commandRows(commands, colors),
+    ...own.length === 0 ? [] : ["", `${colors.bold(`Options of ${defaultCommand}:`)} ${colors.dim("the command run when none is named")}`, ...optionRows(Object.fromEntries(own), colors)],
+    "",
+    colors.bold("Options:"),
+    ...optionRows(path.length === 1 ? TOP_OPTIONS : LEVEL_OPTIONS, colors),
+    ...exampleRows(examples ?? [], colors),
+    "",
+    `${colors.dim("Run")} ${prefix} ${colors.cyan("<command>")} --help ${colors.dim("for its options.")}`
+  ].join(`
+`);
+}
+function printError(prefix, message, hint, cause) {
+  const colors = paint(process4.stderr);
+  const styled = takesControlCodes(process4.stderr);
+  const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
+  const under = (label, text, tint) => text === undefined ? "" : `
+  ${styled ? tint(label) : `${label}:`} ${text}`;
+  console.error(`${head} ${message}${under("cause", cause, colors.dim)}${under("hint", hint, colors.yellow)}`);
+}
+function reportThrown(prefix, error, redact = (text) => text) {
+  if (error instanceof HelpShown)
+    return 0;
+  const help = error instanceof UsageError ? `run ${prefix} --help for its options` : undefined;
+  const named = error instanceof Error && !(error instanceof Exit) && error.name !== "Error" ? `${error.name}: ${error.message}` : undefined;
+  const cause = error instanceof Error && error.cause instanceof Error ? redact(error.cause.message) : undefined;
+  printError(prefix, redact(named ?? (error instanceof Error ? error.message : String(error))), error instanceof Exit ? error.hint ?? help : undefined, cause);
+  return error instanceof Exit ? error.code : 1;
+}
+async function dispatch(level, typed, { version, redact }) {
+  const prefix = level.path.join(" ");
+  let argv;
+  try {
+    argv = takeOutputFlags(typed);
+  } catch (error) {
+    return reportThrown(prefix, error);
+  }
+  const [name, ...args] = argv;
+  if (name === undefined && level.path.length > 1) {
+    console.error(await help(level, process4.stderr));
+    return 2;
+  }
+  if (name === undefined || name === "help" || name === "--help" || name === "-h") {
+    console.log(await help(level, process4.stdout));
+    return 0;
+  }
+  if (level.path.length === 1 && (name === "--version" || name === "-v")) {
+    console.log(version);
+    return 0;
+  }
+  let command = level.commands[level.aliases?.[name] ?? name];
+  let rest = args;
+  if (command === undefined && level.defaultCommand !== undefined) {
+    command = level.commands[level.defaultCommand];
+    rest = argv;
+  }
+  if (command === undefined) {
+    const meant = closest(name, Object.keys(level.commands));
+    printError(prefix, `no command ${name}`, meant === undefined ? `run ${prefix} --help for its commands` : `did you mean ${meant}?`);
+    return 2;
+  }
+  if ("commands" in command) {
+    const { summary } = command;
+    return dispatch({ path: [...level.path, name], header: (colors) => `${colors.bold(`${prefix} ${name}`)}  ${summary}`, commands: command.commands, aliases: command.aliases, defaultCommand: undefined, examples: command.examples }, rest, { version, redact });
+  }
+  try {
+    return await command.run(rest);
+  } catch (error) {
+    return reportThrown(`${prefix} ${name}`, error, redact);
+  }
+}
+async function optionsOf(run) {
+  completion.active = true;
+  try {
+    await run([]);
+  } catch (error) {
+    if (error instanceof Completing)
+      return error.options;
+  } finally {
+    completion.active = false;
+  }
+  return {};
+}
+async function leafCandidates(run, words) {
+  if (!(words.at(-1) ?? "").startsWith("-"))
+    return [FILES];
+  return Object.entries(await optionsOf(run)).map(([name, option]) => `--${name}	${option.description}`);
+}
+async function candidates(commands, aliases, defaultCommand, words) {
+  const [word = "", ...rest] = words;
+  const command = commands[aliases?.[word] ?? word];
+  if (rest.length === 0 && !word.startsWith("-"))
+    return Object.entries(commands).map(([name, { summary }]) => `${name}	${summary}`);
+  if (command === undefined) {
+    const fallback = defaultCommand === undefined ? undefined : commands[defaultCommand];
+    return fallback !== undefined && "run" in fallback ? leafCandidates(fallback.run, words) : [];
+  }
+  return "commands" in command ? candidates(command.commands, command.aliases, undefined, rest) : leafCandidates(command.run, rest);
+}
+async function printCandidates(found) {
+  for (const line of await found)
+    console.log(line);
+  return 0;
+}
+async function runCli(cli, argv = process4.argv.slice(2)) {
+  if (argv[0] === COMPLETE)
+    return printCandidates(candidates(cli.commands, cli.aliases, cli.defaultCommand, argv.slice(1)));
+  return dispatch({ path: [cli.name], header: (colors) => `${colors.bold(cli.name)} ${colors.dim(cli.version)}  ${cli.about}`, commands: cli.commands, aliases: cli.aliases, defaultCommand: cli.defaultCommand, examples: cli.examples }, argv, { version: cli.version, redact: cli.redact });
+}
+var LEVEL_OPTIONS, TOP_OPTIONS, COMPLETE = "__complete", FILES = "__files__";
+var init_cli = __esm(() => {
+  init_args();
+  init_style();
+  init_text();
+  LEVEL_OPTIONS = {
+    ...OUTPUT_OPTIONS,
+    help: { type: "boolean", short: "h", description: "show this help" }
+  };
+  TOP_OPTIONS = { ...LEVEL_OPTIONS, version: { type: "boolean", short: "v", description: "print the version" } };
+});
+
+// ../kit/src/config.ts
+var init_config = __esm(() => {
+  init_args();
+});
+
+// ../kit/src/process.ts
+import { constants } from "os";
+import process5 from "process";
+async function collect(stream, name, chunks) {
+  for await (const data of stream)
+    chunks.push({ stream: name, data });
+}
+function exitCodeOf(code, signal) {
+  if (code !== null)
+    return code;
+  if (typeof signal === "number")
+    return 128 + signal;
+  return signal === null ? 129 : 128 + constants.signals[signal];
+}
+function holdSignals(cleanup) {
+  let received;
+  let child;
+  const held = {
+    get signal() {
+      return received;
+    },
+    forward: (to) => {
+      child = to;
+    },
+    release: () => {
+      for (const signal of SIGNALS)
+        process5.off(signal, onSignal);
+    }
+  };
+  function onSignal(signal) {
+    received = signal;
+    if (child !== undefined) {
+      child.kill(signal);
+      return;
+    }
+    if (cleanup === undefined)
+      return;
+    held.release();
+    cleanup(signal);
+    process5.kill(process5.pid, signal);
+  }
+  for (const signal of SIGNALS)
+    process5.on(signal, onSignal);
+  return held;
+}
+async function runCommand(argv, { cwd, env, stdin = "ignore" } = {}) {
+  const chunks = [];
+  const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe" });
+  await Promise.all([collect(proc.stdout, "stdout", chunks), collect(proc.stderr, "stderr", chunks)]);
+  await proc.exited;
+  const output = Buffer.concat(chunks.map(({ data }) => data));
+  return { code: exitCodeOf(proc.exitCode, proc.signalCode), chunks, output, text: output.toString() };
+}
+var SIGNALS;
+var init_process = __esm(() => {
+  SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+});
+
+// ../kit/src/index.ts
+var init_src = __esm(() => {
+  init_args();
+  init_chart();
+  init_cli();
+  init_config();
+  init_format();
+  init_process();
+  init_style();
+  init_text();
+});
+
+// src/popular.json
+var popular_default;
+var init_popular = __esm(() => {
+  popular_default = [
+    "semver",
+    "minimatch",
+    "debug",
+    "ansi-styles",
+    "brace-expansion",
+    "strip-ansi",
+    "ansi-regex",
+    "ms",
+    "supports-color",
+    "chalk",
+    "commander",
+    "lru-cache",
+    "string-width",
+    "wrap-ansi",
+    "tslib",
+    "picomatch",
+    "emoji-regex",
+    "glob",
+    "type-fest",
+    "color-name",
+    "eslint-visitor-keys",
+    "color-convert",
+    "ajv",
+    "minipass",
+    "source-map",
+    "balanced-match",
+    "readable-stream",
+    "which",
+    "glob-parent",
+    "escape-string-regexp",
+    "has-flag",
+    "find-up",
+    "locate-path",
+    "json-schema-traverse",
+    "p-limit",
+    "yallist",
+    "safe-buffer",
+    "uuid",
+    "p-locate",
+    "undici-types",
+    "ignore",
+    "iconv-lite",
+    "signal-exit",
+    "esbuild",
+    "is-fullwidth-code-point",
+    "js-yaml",
+    "entities",
+    "globals",
+    "postcss",
+    "isexe",
+    "isarray",
+    "path-key",
+    "string_decoder",
+    "argparse",
+    "ws",
+    "mime-db",
+    "resolve",
+    "agent-base",
+    "@esbuild/linux-x64",
+    "yargs-parser",
+    "mime-types",
+    "acorn",
+    "estraverse",
+    "cross-spawn",
+    "react-is",
+    "picocolors",
+    "fs-extra",
+    "hasown",
+    "nanoid",
+    "yargs",
+    "resolve-from",
+    "shebang-command",
+    "pretty-format",
+    "json5",
+    "https-proxy-agent",
+    "path-to-regexp",
+    "path-exists",
+    "punycode",
+    "js-tokens",
+    "cliui",
+    "shebang-regex",
+    "@babel/types",
+    "chokidar",
+    "strip-json-comments",
+    "inherits",
+    "webidl-conversions",
+    "get-stream",
+    "eslint-scope",
+    "cookie",
+    "@babel/parser",
+    "qs",
+    "is-number",
+    "whatwg-url",
+    "@types/estree",
+    "tr46",
+    "convert-source-map",
+    "is-glob",
+    "braces",
+    "fast-deep-equal",
+    "form-data",
+    "lodash",
+    "@babel/helper-validator-identifier",
+    "electron-to-chromium",
+    "fill-range",
+    "function-bind",
+    "readdirp",
+    "escalade",
+    "graceful-fs",
+    "negotiator",
+    "is-stream",
+    "camelcase",
+    "@babel/runtime",
+    "yocto-queue",
+    "to-regex-range",
+    "node-fetch",
+    "micromatch",
+    "node-releases",
+    "get-intrinsic",
+    "universalify",
+    "path-scurry",
+    "jsesc",
+    "browserslist",
+    "es-errors",
+    "statuses",
+    "@radix-ui/react-primitive",
+    "magic-string",
+    "rimraf",
+    "is-extglob",
+    "@jridgewell/trace-mapping",
+    "@jridgewell/resolve-uri",
+    "http-errors",
+    "onetime",
+    "has-symbols",
+    "es-define-property",
+    "gopd",
+    "util-deprecate",
+    "object-assign",
+    "jiti",
+    "yaml",
+    "dotenv",
+    "@babel/generator",
+    "@babel/template",
+    "imurmurhash",
+    "postcss-selector-parser",
+    "fast-glob",
+    "update-browserslist-db",
+    "@types/node",
+    "@babel/compat-data",
+    "eventemitter3",
+    "callsites",
+    "http-proxy-agent",
+    "detect-libc",
+    "espree",
+    "execa",
+    "@babel/core",
+    "@babel/helpers",
+    "concat-map",
+    "source-map-js",
+    "tinyglobby",
+    "call-bind-apply-helpers",
+    "flat-cache",
+    "fdir",
+    "pify",
+    "@jest/types",
+    "normalize-path",
+    "is-core-module",
+    "eslint",
+    "minimist",
+    "estree-walker",
+    "file-entry-cache",
+    "object-inspect",
+    "buffer",
+    "uri-js",
+    "import-fresh",
+    "@babel/helper-module-transforms",
+    "optionator",
+    "flatted",
+    "math-intrinsics",
+    "safer-buffer",
+    "y18n",
+    "@babel/helper-module-imports",
+    "mkdirp",
+    "dunder-proto",
+    "path-parse",
+    "fastq",
+    "levn",
+    "@babel/helper-compilation-targets",
+    "@babel/helper-string-parser",
+    "keyv",
+    "get-proto",
+    "csstype",
+    "npm-run-path",
+    "fast-json-stable-stringify",
+    "reusify",
+    "@babel/helper-plugin-utils",
+    "kind-of",
+    "mime",
+    "caniuse-lite",
+    "lines-and-columns",
+    "fast-levenshtein",
+    "supports-preserve-symlinks-flag",
+    "make-dir",
+    "slash",
+    "prelude-ls",
+    "typescript",
+    "strip-bom",
+    "parent-module",
+    "esutils",
+    "ci-info",
+    "@smithy/util-utf8",
+    "type-check",
+    "mimic-fn",
+    "@babel/helper-validator-option",
+    "@types/json-schema",
+    "@rolldown/pluginutils",
+    "side-channel-list",
+    "json-buffer",
+    "raw-body",
+    "has-tostringtag",
+    "wrappy",
+    "diff",
+    "jackspeak",
+    "baseline-browser-mapping",
+    "deep-is",
+    "foreground-child",
+    "@eslint/js",
+    "anymatch",
+    "natural-compare",
+    "esquery",
+    "@eslint-community/regexpp",
+    "es-set-tostringtag",
+    "acorn-jsx",
+    "parse5",
+    "finalhandler",
+    "parse-json",
+    "depd",
+    "axios",
+    "run-parallel",
+    "source-map-support",
+    "esrecurse",
+    "call-bound",
+    "content-disposition",
+    "human-signals",
+    "ts-api-utils",
+    "ansi-escapes",
+    "jest-util",
+    "send",
+    "@opentelemetry/core",
+    "type-is",
+    "encodeurl",
+    "once",
+    "cosmiconfig",
+    "lodash.merge",
+    "json-stable-stringify-without-jsonify",
+    "open",
+    "prettier",
+    "@eslint/eslintrc",
+    "is-arrayish",
+    "@jridgewell/sourcemap-codec",
+    "gensync",
+    "word-wrap",
+    "express",
+    "arg",
+    "jsonfile",
+    "schema-utils",
+    "@smithy/is-array-buffer",
+    "@typescript-eslint/types",
+    "chownr",
+    "delayed-stream",
+    "@smithy/util-buffer-from",
+    "asynckit",
+    "tapable",
+    "enhanced-resolve",
+    "aria-query",
+    "indent-string",
+    "bytes",
+    "binary-extensions",
+    "ini",
+    "@radix-ui/react-context",
+    "doctrine",
+    "queue-microtask",
+    "accepts",
+    "merge2",
+    "get-caller-file",
+    "@humanwhocodes/retry",
+    "@jridgewell/gen-mapping",
+    "@typescript-eslint/typescript-estree",
+    "jest-worker",
+    "proxy-from-env",
+    "clsx",
+    "side-channel-map",
+    "@typescript-eslint/visitor-keys",
+    "fresh",
+    "restore-cursor",
+    "on-finished",
+    "is-plain-obj",
+    "ipaddr.js",
+    "pathe",
+    "@jest/schemas",
+    "base64-js",
+    "@smithy/types",
+    "require-directory",
+    "tough-cookie",
+    "is-binary-path",
+    "body-parser",
+    "postcss-value-parser",
+    "media-typer",
+    "setprototypeof",
+    "side-channel-weakmap",
+    "@typescript-eslint/tsconfig-utils",
+    "@isaacs/cliui",
+    "@rollup/rollup-linux-x64-gnu",
+    "is-wsl",
+    "retry",
+    "@aws-sdk/types",
+    "@types/react-dom",
+    "combined-stream",
+    "es-object-atoms",
+    "@eslint/core",
+    "whatwg-mimetype",
+    "domutils",
+    "@rollup/rollup-linux-x64-musl",
+    "core-util-is",
+    "@typescript-eslint/scope-manager",
+    "esprima",
+    "loose-envify",
+    "cookie-signature",
+    "follow-redirects",
+    "cli-cursor",
+    "strip-final-newline",
+    "@typescript-eslint/project-service",
+    "eastasianwidth",
+    "json-parse-even-better-errors",
+    "sprintf-js",
+    "path-type",
+    "content-type",
+    "es-module-lexer",
+    "@nodelib/fs.scandir",
+    "write-file-atomic",
+    "@eslint/plugin-kit",
+    "ieee754",
+    "prop-types",
+    "require-from-string",
+    "dom-serializer",
+    "call-bind",
+    "@eslint/config-array",
+    "has-property-descriptors",
+    "@nodelib/fs.stat",
+    "merge-descriptors",
+    "slice-ansi",
+    "rxjs",
+    "p-map",
+    "toidentifier",
+    "globby",
+    "domhandler",
+    "async",
+    "@babel/helper-globals",
+    "pirates",
+    "@opentelemetry/semantic-conventions",
+    "@typescript-eslint/utils",
+    "date-fns",
+    "is-docker",
+    "tar",
+    "which-typed-array",
+    "ajv-formats",
+    "@opentelemetry/api-logs",
+    "@opentelemetry/resources",
+    "side-channel",
+    "cjs-module-lexer",
+    "range-parser",
+    "@humanfs/node",
+    "define-data-property",
+    "node-addon-api",
+    "pako",
+    "lilconfig",
+    "fast-uri",
+    "ip-address",
+    "fs.realpath",
+    "@img/sharp-libvips-linuxmusl-x64",
+    "cssesc",
+    "@opentelemetry/instrumentation",
+    "domelementtype",
+    "hosted-git-info",
+    "@eslint/object-schema",
+    "etag",
+    "@eslint/config-helpers",
+    "package-json-from-dist",
+    "@humanfs/core",
+    "htmlparser2",
+    "jest-message-util",
+    "for-each",
+    "pkg-dir",
+    "unpipe",
+    "buffer-from",
+    "es-abstract",
+    "is-unicode-supported",
+    "@types/yargs",
+    "is-callable",
+    "fast-xml-parser",
+    "istanbul-lib-instrument",
+    "escape-html",
+    "is-regex",
+    "dom-accessibility-api",
+    "css-tree",
+    "error-ex",
+    "ee-first",
+    "@types/unist",
+    "log-symbols",
+    "path-is-absolute",
+    "end-of-stream",
+    "@vitest/utils",
+    "object.assign",
+    "object-keys",
+    "tinyexec",
+    "scheduler",
+    "p-try",
+    "process-nextick-args",
+    "vary",
+    "@babel/traverse",
+    "@pkgjs/parseargs",
+    "@types/babel__generator",
+    "kleur",
+    "zod",
+    "merge-stream",
+    "available-typed-arrays",
+    "mute-stream",
+    "is-typed-array",
+    "safe-regex-test",
+    "tsconfig-paths",
+    "minizlib",
+    "tar-stream",
+    "@floating-ui/core",
+    "jose",
+    "deepmerge",
+    "get-tsconfig",
+    "set-function-length",
+    "@vitest/spy",
+    "css-select",
+    "@types/babel__core",
+    "forwarded",
+    "react",
+    "@typescript-eslint/parser",
+    "ajv-keywords",
+    "define-properties",
+    "is-generator-function",
+    "regexp.prototype.flags",
+    "acorn-walk",
+    "pump",
+    "data-uri-to-buffer",
+    "object-hash",
+    "jsdom",
+    "nopt",
+    "@babel/plugin-syntax-jsx",
+    "@floating-ui/dom",
+    "tiny-invariant",
+    "strip-indent",
+    "d3-array",
+    "chai",
+    "@babel/code-frame",
+    "@typescript-eslint/eslint-plugin",
+    "proxy-addr",
+    "parseurl",
+    "@floating-ui/utils",
+    "ora",
+    "html-encoding-sniffer",
+    "pnpm",
+    "whatwg-encoding",
+    "events",
+    "@typescript-eslint/type-utils",
+    "env-paths",
+    "internal-slot",
+    "string.prototype.trimend",
+    "extend",
+    "resolve-pkg-maps",
+    "istanbul-lib-coverage",
+    "react-dom",
+    "is-number-object",
+    "@radix-ui/primitive",
+    "is-plain-object",
+    "string.prototype.trimstart",
+    "@babel/plugin-syntax-typescript",
+    "jest-diff",
+    "define-lazy-prop",
+    "globalthis",
+    "which-boxed-primitive",
+    "@vitest/expect",
+    "sax",
+    "@floating-ui/react-dom",
+    "@vitest/pretty-format",
+    "internmap",
+    "@radix-ui/react-compose-refs",
+    "is-symbol",
+    "@eslint-community/eslint-utils",
+    "bl",
+    "serve-static",
+    "get-symbol-description",
+    "is-shared-array-buffer",
+    "functions-have-names",
+    "array-buffer-byte-length",
+    "socks-proxy-agent"
+  ];
+});
+
+// src/nearmiss.ts
+function baseName(name) {
+  return name.slice(name.indexOf("/") + 1);
+}
+function scopeOf(name) {
+  return name.startsWith("@") ? name.slice(0, name.indexOf("/")) : "";
+}
+function squash(name) {
+  return name.toLowerCase().replace(SEPARATORS, "");
+}
+function resemblance(name, popular) {
+  if (scopeOf(name) !== scopeOf(popular) && baseName(name) === baseName(popular) && baseName(name).length >= MIN_LENGTH)
+    return `${popular} under another scope`;
+  if (squash(name) === squash(popular))
+    return `${popular} spelled with other separators or case`;
+  const edits = distance(name, popular);
+  const allowed = Math.min(name.length, popular.length) >= MIN_LENGTH * 2 ? 2 : 1;
+  return Math.min(name.length, popular.length) >= MIN_LENGTH && edits <= allowed ? `${popular}, ${edits} ${edits === 1 ? "edit" : "edits"} away` : undefined;
+}
+function nearMisses(name, popular = popular_default) {
+  if (popular.includes(name))
+    return [];
+  const found = [];
+  for (const other of popular) {
+    const text = resemblance(name, other);
+    if (text !== undefined)
+      found.push({ text, edits: distance(name, other) });
+  }
+  return found.sort((a, b) => a.edits - b.edits).slice(0, 3).map((match) => match.text);
+}
+var SEPARATORS, MIN_LENGTH = 5;
+var init_nearmiss = __esm(() => {
+  init_src();
+  init_popular();
+  SEPARATORS = /[-_.]/g;
+});
+
+// src/analyze.ts
+function parseSpec(text) {
+  const at = text.search(VERSION_SEPARATOR);
+  return at === -1 ? { name: text } : { name: text.slice(0, at), request: text.slice(at + 1) };
+}
+function isStable(version) {
+  return !version.includes("-");
+}
+function resolve(packument, request) {
+  const tags = packument["dist-tags"] ?? {};
+  const versions = Object.keys(packument.versions ?? {});
+  const wanted = request === undefined || request === "" ? "latest" : request;
+  if (tags[wanted] !== undefined)
+    return tags[wanted];
+  if (versions.includes(wanted))
+    return wanted;
+  return versions.filter((version) => Bun.semver.satisfies(version, wanted)).sort(Bun.semver.order).at(-1);
+}
+function licenseOf(license) {
+  return typeof license === "string" ? license : license?.type;
+}
+function repositoryOf(packument) {
+  const repository = typeof packument.repository === "string" ? packument.repository : packument.repository?.url;
+  return repository?.replace(GIT_PREFIX, "") ?? packument.homepage;
+}
+function ageDays(published, now) {
+  const at = Date.parse(published ?? "");
+  return Number.isNaN(at) ? undefined : (now - at) / DAY;
+}
+function installScriptsOf(version) {
+  return Object.fromEntries(INSTALL_SCRIPTS.flatMap((name) => version?.scripts?.[name] === undefined ? [] : [[name, version.scripts[name]]]));
+}
+function safeRelease(packument, now, minAgeDays) {
+  const old = Object.keys(packument.versions ?? {}).filter((version) => isStable(version) && (ageDays(packument.time?.[version], now) ?? 0) >= minAgeDays && packument.time?.[version] !== undefined);
+  const version = old.sort(Bun.semver.order).at(-1);
+  return version === undefined ? undefined : { version, published: packument.time?.[version] };
+}
+function analyze(input) {
+  const { spec, packument, registry, now = Date.now(), minAgeDays = DEFAULT_MIN_AGE_DAYS } = input;
+  const report = { name: spec.name, registry, exists: packument !== undefined, requested: spec.request, installScripts: {}, nearMisses: nearMisses(spec.name), warnings: [], blocked: false, downloads: input.downloads };
+  if (report.nearMisses.length > 0)
+    report.warnings.push(`name looks like ${report.nearMisses.join("; ")}, check it is the package meant`);
+  if (packument === undefined) {
+    report.blocked = true;
+    report.warnings.unshift(`${spec.name} is not on ${registry}, the name may be guessed`);
+    return report;
+  }
+  const latest = packument["dist-tags"]?.latest;
+  const version = resolve(packument, spec.request);
+  const entry = version === undefined ? undefined : packument.versions?.[version];
+  report.description = packument.description;
+  report.license = licenseOf(entry?.license) ?? licenseOf(packument.license);
+  report.repository = repositoryOf(packument);
+  report.latest = latest === undefined ? undefined : { version: latest, published: packument.time?.[latest] };
+  report.safe = safeRelease(packument, now, minAgeDays);
+  report.version = version;
+  report.published = version === undefined ? undefined : packument.time?.[version];
+  report.installScripts = installScriptsOf(entry);
+  report.deprecated = entry?.deprecated;
+  if (version === undefined) {
+    report.blocked = true;
+    report.warnings.push(`no version of ${spec.name} matches ${spec.request}`);
+    return report;
+  }
+  const age = ageDays(report.published, now);
+  if (age === undefined) {
+    report.warnings.push(`${registry} gives no publish date for ${version}, its age cannot be checked`);
+  } else if (age < minAgeDays) {
+    report.blocked = true;
+    report.warnings.push(`${version} was published ${age < 1 ? "less than a day" : `${Math.floor(age)} day${Math.floor(age) === 1 ? "" : "s"}`} ago, under ${minAgeDays} days${report.safe === undefined ? ", and no older stable version exists" : `, use ${spec.name}@${report.safe.version}`}`);
+  }
+  const scripts = Object.keys(report.installScripts);
+  if (scripts.length > 0)
+    report.warnings.push(`${version} runs ${scripts.join(", ")} at install`);
+  if (report.deprecated !== undefined)
+    report.warnings.push(`${version} is deprecated: ${report.deprecated}`);
+  return report;
+}
+var DEFAULT_MIN_AGE_DAYS = 14, DAY = 86400000, INSTALL_SCRIPTS, GIT_PREFIX, VERSION_SEPARATOR;
+var init_analyze = __esm(() => {
+  init_nearmiss();
+  INSTALL_SCRIPTS = ["preinstall", "install", "postinstall"];
+  GIT_PREFIX = /^git\+/;
+  VERSION_SEPARATOR = /(?<=.)@/;
+});
+
+// src/registry.ts
+function isPublic(registry) {
+  return registry.url.replace(TRAILING_SLASHES, "") === PUBLIC_REGISTRY;
+}
+async function get(fetcher, url, token) {
+  try {
+    return await fetcher(url, { headers: { accept: "application/json", ...token === undefined ? {} : { authorization: `Bearer ${token}` } } });
+  } catch (error) {
+    return fail(`cannot reach ${new URL(url).host}: ${error instanceof Error ? error.message : String(error)}`, 1);
+  }
+}
+async function fetchPackument(name, registry, fetcher = fetch) {
+  const response = await get(fetcher, `${registry.url.replace(TRAILING_SLASHES, "")}/${name.replace("/", "%2f")}`, registry.token);
+  if (response.status === 404)
+    return;
+  if (!response.ok)
+    fail(`${new URL(registry.url).host} answered ${response.status} for ${name}`, 1);
+  return await response.json();
+}
+async function fetchDownloads(name, fetcher = fetch) {
+  const response = await get(fetcher, `${DOWNLOADS_API}/${name}`);
+  if (!response.ok)
+    return;
+  const body = await response.json();
+  return body.downloads;
+}
+var PUBLIC_REGISTRY = "https://registry.npmjs.org", DOWNLOADS_API = "https://api.npmjs.org/downloads/point/last-week", TRAILING_SLASHES;
+var init_registry = __esm(() => {
+  init_src();
+  TRAILING_SLASHES = /\/+$/;
+});
+
+// src/config.ts
+import { homedir } from "os";
+import { dirname, join } from "path";
+import process7 from "process";
+function expand(value, env) {
+  let missing = false;
+  const expanded = value.replace(ENV_REFERENCE, (_, braced, bare) => {
+    const found = env[braced ?? bare ?? ""];
+    missing ||= found === undefined;
+    return found ?? "";
+  });
+  return missing ? undefined : expanded;
+}
+function parseNpmrc(text, env) {
+  const config = { scopes: {}, tokens: {}, scopeTokens: {} };
+  for (const line of text.split(`
+`)) {
+    const at = line.indexOf("=");
+    if (at === -1 || COMMENT.test(line))
+      continue;
+    const key = line.slice(0, at).trim();
+    const value = expand(line.slice(at + 1).trim().replace(QUOTES, "$2"), env);
+    if (value === undefined || value === "")
+      continue;
+    const scope = SCOPE_REGISTRY.exec(key)?.[1];
+    const tokenFor = AUTH_TOKEN.exec(key)?.[1];
+    if (scope !== undefined)
+      config.scopes[scope] = value;
+    else if (tokenFor !== undefined)
+      config.tokens[tokenFor] = value;
+    else if (key === "registry")
+      config.registry = value;
+  }
+  return config;
+}
+function bunEntry(entry, env) {
+  const url = typeof entry === "string" ? entry : entry.url;
+  const token = typeof entry === "string" || entry.token === undefined ? undefined : expand(entry.token, env);
+  return { ...url === undefined ? {} : { url: expand(url, env) ?? url }, ...token === undefined ? {} : { token } };
+}
+function parseBunfig(text, env) {
+  const config = { scopes: {}, tokens: {}, scopeTokens: {} };
+  const install = Bun.TOML.parse(text).install;
+  if (install?.registry !== undefined) {
+    const { url, token } = bunEntry(install.registry, env);
+    if (url !== undefined)
+      config.registry = url;
+    if (url !== undefined && token !== undefined)
+      config.tokens[url.replace(PROTOCOL, "")] = token;
+  }
+  for (const [scope, entry] of Object.entries(install?.scopes ?? {})) {
+    const { url, token } = bunEntry(entry, env);
+    if (url !== undefined)
+      config.scopes[scope.startsWith("@") ? scope : `@${scope}`] = url;
+    if (token !== undefined)
+      config.scopeTokens[scope.startsWith("@") ? scope : `@${scope}`] = token;
+  }
+  return config;
+}
+function tokenFor(config, url) {
+  const address = url.replace(PROTOCOL, "");
+  const best = Object.keys(config.tokens).filter((key) => address.startsWith(key)).sort((a, b) => b.length - a.length)[0];
+  return best === undefined ? undefined : config.tokens[best];
+}
+function registryFor(name, configs) {
+  const scope = name.startsWith("@") ? name.slice(0, name.indexOf("/")) : undefined;
+  for (const config of configs) {
+    const url = scope === undefined ? config.registry : config.scopes[scope] ?? config.registry;
+    if (url === undefined)
+      continue;
+    const token = (scope === undefined ? undefined : config.scopeTokens[scope]) ?? tokenFor(config, url) ?? configs.map((other) => tokenFor(other, url)).find((found) => found !== undefined);
+    return { url, token };
+  }
+  return { url: PUBLIC_REGISTRY };
+}
+async function readIfThere(path) {
+  const file = Bun.file(path);
+  return await file.exists() ? file.text() : undefined;
+}
+async function loadConfigs(cwd = process7.cwd(), env = process7.env, home = homedir()) {
+  const directories = [];
+  for (let dir = cwd;!directories.includes(dir); dir = dirname(dir))
+    directories.push(dir);
+  if (!directories.includes(home))
+    directories.push(home);
+  const configs = [];
+  for (const dir of directories) {
+    const bunfig = await readIfThere(join(dir, "bunfig.toml"));
+    const npmrc = await readIfThere(join(dir, ".npmrc"));
+    if (bunfig !== undefined)
+      configs.push(parseBunfig(bunfig, env));
+    if (npmrc !== undefined)
+      configs.push(parseNpmrc(npmrc, env));
+  }
+  return configs;
+}
+var ENV_REFERENCE, COMMENT, SCOPE_REGISTRY, AUTH_TOKEN, PROTOCOL, QUOTES;
+var init_config2 = __esm(() => {
+  init_registry();
+  ENV_REFERENCE = /\$\{(\w+)\}|\$(\w+)/g;
+  COMMENT = /^\s*[#;]/;
+  SCOPE_REGISTRY = /^(@[^:]+):registry$/;
+  AUTH_TOKEN = /^(\/\/.+?):_authToken$/;
+  PROTOCOL = /^\w+:/;
+  QUOTES = /^(["'])(.*)\1$/;
+});
+
+// src/commands/check.ts
+var exports_check = {};
+__export(exports_check, {
+  check: () => check
+});
+async function checkPackage(text, context) {
+  const spec = parseSpec(text);
+  const registry = registryFor(spec.name, context.configs);
+  const packument = await fetchPackument(spec.name, registry, context.fetcher);
+  const downloads = packument !== undefined && isPublic(registry) ? await fetchDownloads(spec.name, context.fetcher) : undefined;
+  return analyze({ spec, packument, downloads, registry: new URL(registry.url).host, now: context.now, minAgeDays: context.minAgeDays });
+}
+function when(release, now) {
+  return release?.published === undefined ? "" : `, published ${formatAge(release.published, now)} (${release.published.slice(0, 10)})`;
+}
+function render(report, now = Date.now()) {
+  if (!report.exists)
+    return [report.name, ...report.warnings.map((warning) => `  warning: ${warning}`)].join(`
+`);
+  const asked = report.requested === undefined ? "" : ` (asked for ${report.requested})`;
+  const rows = [
+    ["version", report.version === undefined ? `none${asked}` : `${report.version}${asked}${when(report, now)}`],
+    ["latest", report.latest === undefined ? "-" : `${report.latest.version}${when(report.latest, now)}`],
+    ["safe", report.safe === undefined ? "-" : `${report.safe.version}${when(report.safe, now)}`],
+    ["downloads", report.downloads === undefined ? "-" : `${report.downloads.toLocaleString("en-US")} last week`],
+    ["license", report.license ?? "-"],
+    ["repository", report.repository ?? "-"],
+    ...Object.entries(report.installScripts).map(([name, command]) => [name, command])
+  ];
+  return [
+    `${report.name}${report.description === undefined ? "" : `: ${report.description}`}`,
+    table(rows.map(([key, value]) => [`  ${key}`, value ?? ""])),
+    ...report.warnings.map((warning) => `  warning: ${warning}`)
+  ].join(`
+`);
+}
+async function check(args) {
+  const parsed = parse(args, usage, options);
+  const { values, positionals } = parsed;
+  if (positionals.length === 0)
+    fail(`a package name is needed
+
+${usage}`);
+  const context = { configs: await loadConfigs(), minAgeDays: wholeNumber(values["min-age"], "min-age", DEFAULT_MIN_AGE_DAYS, 0) };
+  const reports = await Promise.all(positionals.map(async (text) => checkPackage(text, context)));
+  if (values.json === true)
+    printJson(reports.length === 1 ? reports[0] : reports);
+  else
+    console.log(reports.map((report) => render(report)).join(`
+
+`));
+  return reports.some((report) => report.blocked) ? 1 : 0;
+}
+var usage = `pkg [check] <name>[@version]...
+
+Checks npm packages before they are added: whether the name exists, the latest and the newest version at least two weeks old, weekly downloads, licence, repository, install scripts and a near miss of a popular name.
+Exits 1 when a package is missing or the version asked for is under the minimum age.`, options;
+var init_check = __esm(() => {
+  init_src();
+  init_analyze();
+  init_config2();
+  init_registry();
+  options = {
+    json: jsonOption(),
+    "min-age": { type: "string", description: `days a version must be old (${DEFAULT_MIN_AGE_DAYS})` }
+  };
+});
+
+// ../kit/src/progress.ts
+import process8 from "process";
+function liveRegion(render, stream = process8.stderr, env = process8.env) {
+  if (!takesControlCodes(stream, env))
+    return { redraw: () => {
+      return;
+    }, print: (text) => void stream.write(`${text}
+`), stop: () => {
+      return;
+    } };
+  const write = stream.write.bind(stream);
+  let frame = 0;
+  let drawn = 0;
+  const clear = () => {
+    if (drawn > 0)
+      write(`${CLEAR_LINE}${LINE_UP.repeat(drawn - 1)}`);
+    drawn = 0;
+  };
+  const draw = () => {
+    const width = (stream.columns === undefined || stream.columns === 0 ? 80 : stream.columns) - 1;
+    const height = stream.rows === undefined || stream.rows === 0 ? 24 : stream.rows;
+    const lines = render(FRAMES[frame++ % FRAMES.length]).slice(0, Math.max(1, height - 1)).map((line) => cutToWidth(line, width));
+    if (lines.length === 0) {
+      clear();
+      return;
+    }
+    write(`${drawn > 0 ? `${CLEAR_LINE}${LINE_UP.repeat(drawn - 1)}` : CLEAR_LINE}${lines.join(`
+`)}`);
+    drawn = lines.length;
+  };
+  const timer = setInterval(draw, FRAME_MS);
+  const restore = interceptOutput(clear);
+  const onExit = () => clear();
+  const signals = holdSignals(stop);
+  function stop() {
+    clearInterval(timer);
+    clear();
+    restore();
+    process8.off("exit", onExit);
+    signals.release();
+  }
+  timer.unref();
+  process8.on("exit", onExit);
+  return {
+    redraw: draw,
+    print: (text) => {
+      clear();
+      write(`${text}
+`);
+      draw();
+    },
+    stop
+  };
+}
+function cutToWidth(line, width) {
+  if (Bun.stringWidth(line) <= width)
+    return line;
+  let room = width;
+  let kept = "";
+  let index = 0;
+  let linked = false;
+  while (index < line.length) {
+    ESCAPE_CODE.lastIndex = index;
+    const escape = ESCAPE_CODE.exec(line);
+    if (escape !== null) {
+      kept += escape[0];
+      linked ||= escape[0].startsWith(`${ESC}]`);
+      index = ESCAPE_CODE.lastIndex;
+      continue;
+    }
+    const char = String.fromCodePoint(line.codePointAt(index));
+    const columns = Bun.stringWidth(char);
+    if (columns > room)
+      break;
+    kept += char;
+    room -= columns;
+    index += char.length;
+  }
+  return `${kept}${RESET_STYLE}${linked ? CLOSE_LINK : ""}`;
+}
+function interceptOutput(clear) {
+  const targets = [...CONSOLE_METHODS.map((name) => [console, name]), [process8.stdout, "write"], [process8.stderr, "write"]];
+  const wrapped = targets.map(([target, name]) => {
+    const original = Reflect.get(target, name);
+    const wrapper = (...args) => {
+      clear();
+      return original.apply(target, args);
+    };
+    Reflect.set(target, name, wrapper);
+    return { target, name, original, wrapper };
+  });
+  return () => {
+    for (const { target, name, original, wrapper } of wrapped) {
+      if (Reflect.get(target, name) === wrapper)
+        Reflect.set(target, name, original);
+    }
+  };
+}
+var FRAMES, FRAME_MS = 80, CLEAR_LINE = "\r\x1B[2K", LINE_UP = "\x1B[1A\x1B[2K", ESC, ESCAPE_CODE, RESET_STYLE, CLOSE_LINK, CONSOLE_METHODS;
+var init_progress = __esm(() => {
+  init_format();
+  init_process();
+  init_style();
+  FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  ESC = String.fromCharCode(27);
+  ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
+  RESET_STYLE = `${ESC}[0m`;
+  CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
+  CONSOLE_METHODS = ["log", "info", "warn", "error", "debug", "dir", "dirxml", "table", "trace", "group", "groupCollapsed", "count", "timeEnd", "timeLog", "assert"];
+});
+
+// ../kit/src/shell.ts
+var SEPARATORS2, PLAIN_BREAKERS, DOUBLE_QUOTED_ESCAPES, WRAPPERS;
+var init_shell = __esm(() => {
+  SEPARATORS2 = new Set([`
+`, ";", "|"]);
+  PLAIN_BREAKERS = new Set(["<", ">", "(", ")", "&", "|"]);
+  DOUBLE_QUOTED_ESCAPES = new Set(["$", "`", '"', "\\"]);
+  WRAPPERS = new Set(["command", "env", "sudo", "exec", "nohup", "time"]);
+});
+
+// src/pin.ts
+function actions(byAction) {
+  return new Map(Object.entries(byAction).flatMap(([action, names]) => names.map((name) => [name, action])));
+}
+var LOCKFILES, ACTIONS, OPTION_FLAGS, DIR_FLAGS, VALUE_FLAGS;
+var init_pin = __esm(() => {
+  init_shell();
+  LOCKFILES = [
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["package-lock.json", "npm"]
+  ];
+  ACTIONS = {
+    bun: actions({ install: ["install", "i"], add: ["add", "a"], remove: ["remove", "rm"], update: ["update"] }),
+    pnpm: actions({ install: ["install", "i"], add: ["add"], remove: ["remove", "rm"], update: ["update", "up"] }),
+    yarn: new Map([...actions({ install: ["", "install"], add: ["add"], remove: ["remove"], update: ["upgrade"] }), ["upgrade-interactive", null], ["import", null]]),
+    npm: actions({
+      install: ["install", "i", "in", "ins", "inst", "insta", "instal", "isnt", "isnta", "isntal", "isntall"],
+      add: ["add"],
+      frozen: ["ci", "clean-install", "ic", "install-clean", "isntall-clean"],
+      remove: ["uninstall", "unlink", "remove", "rm", "r", "un"],
+      update: ["update", "u", "up", "upgrade", "udpate"]
+    })
+  };
+  OPTION_FLAGS = new Map([
+    ["-D", "dev"],
+    ["--save-dev", "dev"],
+    ["--dev", "dev"],
+    ["-E", "exact"],
+    ["--save-exact", "exact"],
+    ["--exact", "exact"]
+  ]);
+  DIR_FLAGS = new Set(["--cwd", "-C", "--dir", "--prefix"]);
+  VALUE_FLAGS = new Set([...DIR_FLAGS, "--filter", "-F"]);
+});
+
+// src/consumers.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { dirname as dirname2, join as join2, relative } from "path";
+function packageFiles(dir, depth, found) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return found;
+  }
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name === "package.json")
+      found.push(join2(dir, entry.name));
+    else if (entry.isDirectory() && depth < MAX_DEPTH && !entry.name.startsWith(".") && !SKIPPED.has(entry.name))
+      packageFiles(join2(dir, entry.name), depth + 1, found);
+  }
+  return found;
+}
+function managerFor(dir, root) {
+  for (let at = dir;; at = dirname2(at)) {
+    const lockfile = LOCKFILES.find(([file]) => existsSync(join2(at, file)));
+    if (lockfile !== undefined)
+      return lockfile[1];
+    if (at === root || at === dirname2(at))
+      return "bun";
+  }
+}
+function findConsumers(name, root) {
+  const consumers = [];
+  for (const path of packageFiles(root, 0, []).sort()) {
+    let manifest;
+    try {
+      manifest = JSON.parse(readFileSync(path, "utf8"));
+    } catch {
+      continue;
+    }
+    const kind = KINDS.find((each) => typeof manifest[each]?.[name] === "string");
+    const spec = kind === undefined ? undefined : manifest[kind]?.[name];
+    if (kind !== undefined && spec !== undefined)
+      consumers.push({ dir: relative(root, dirname2(path)) || ".", path, kind, spec, manager: managerFor(dirname2(path), root) });
+  }
+  return consumers;
+}
+function isLocal(consumer) {
+  return LOCAL_SPEC.test(consumer.spec);
+}
+function addCommand(consumer, name, version) {
+  return ["bun", "add", ...KIND_FLAGS[consumer.kind], "--exact", "--no-cache", `${name}@${version}`];
+}
+var KINDS, SKIPPED, MAX_DEPTH = 5, LOCAL_SPEC, KIND_FLAGS;
+var init_consumers = __esm(() => {
+  init_pin();
+  KINDS = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
+  SKIPPED = new Set(["node_modules", "dist", "build", "vendor", "target", "coverage"]);
+  LOCAL_SPEC = /^(?:workspace|link|file|portal):/;
+  KIND_FLAGS = { dependencies: [], devDependencies: ["--dev"], optionalDependencies: ["--optional"], peerDependencies: ["--peer"] };
+});
+
+// src/commands/bump.ts
+var exports_bump = {};
+__export(exports_bump, {
+  ROOT_OPTION: () => ROOT_OPTION,
+  bump: () => bump
+});
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+async function servedVersion(name, version, settings) {
+  const registry = registryFor(name, settings.configs);
+  const host = new URL(registry.url).host;
+  const started = Date.now();
+  const region = liveRegion((spinner) => [`${spinner} waiting for ${host} to serve ${name}@${version} ${formatDuration(Date.now() - started)}`]);
+  try {
+    for (;; ) {
+      const packument = await fetchPackument(name, registry, settings.fetcher);
+      const latest = packument?.["dist-tags"]?.latest;
+      if (version === undefined && latest !== undefined)
+        return latest;
+      if (version === undefined)
+        fail(`${host} has no ${name}`, 1);
+      if (packument?.versions?.[version] !== undefined)
+        return version;
+      if (Date.now() - started >= settings.timeout)
+        fail(`${host} does not serve ${name}@${version} after ${formatDuration(settings.timeout)}`, 1);
+      region.redraw();
+      await Bun.sleep(settings.poll ?? POLL);
+    }
+  } finally {
+    region.stop();
+  }
+}
+async function bumpConsumers(name, version, settings) {
+  const found = findConsumers(name, settings.root);
+  const consumers = found.filter((each) => !isLocal(each));
+  const local = found.length - consumers.length;
+  const run = settings.run ?? (async (argv, cwd) => runCommand(argv, { cwd }));
+  let isClean = true;
+  if (found.length === 0)
+    note(`nothing under ${settings.root} depends on ${name}`);
+  if (local > 0)
+    note(`${local} workspace:, link: or file: dependenc${local === 1 ? "y" : "ies"}`, "left as they are");
+  for (const consumer of consumers) {
+    const argv = addCommand(consumer, name, version);
+    const where = join3(settings.root, consumer.dir);
+    if (consumer.spec === version) {
+      note(consumer.dir, `already on ${version}`);
+    } else if (consumer.manager !== "bun") {
+      warn(consumer.dir, `${consumer.spec}, its lockfile pins ${consumer.manager}: put ${version} in by hand`);
+    } else if (settings.isDryRun === true) {
+      note(consumer.dir, `would run ${argv.join(" ")}`);
+    } else {
+      const ran = await run(argv, where);
+      if (ran.code === 0) {
+        ok(consumer.dir, `${consumer.spec} -> ${version}`);
+      } else {
+        isClean = false;
+        problem(consumer.dir, `${argv.join(" ")} exited ${ran.code}: ${ran.text.trim().split(`
+`).at(-1) ?? ""}`);
+      }
+    }
+  }
+  return isClean;
+}
+async function bump(args) {
+  const { values, positionals: [name, asked] } = parse(args, usage2, options2, { positionals: ["<name>", "[version]"] });
+  const settings = {
+    root: values.root ?? join3(homedir2(), "Workspace"),
+    configs: await loadConfigs(),
+    timeout: duration(values.timeout, "timeout", 10 * 60000),
+    isDryRun: values["dry-run"] === true
+  };
+  const version = await servedVersion(name, asked, settings);
+  return await bumpConsumers(name, version, settings) ? 0 : 1;
+}
+var usage2 = `pkg bump <name> [version]
+
+Waits until the registry serves the version (the latest when none is given), then runs \`bun add --exact --no-cache\` in each folder under --root whose package.json depends on the package, the kind of dependency kept, a line per folder.
+A workspace:, link: or file: dependency, a folder already on the version and one whose lockfile pins another manager are left as they are, each said so.
+Exits 1 when an install fails or the version never shows, 2 on a usage error.`, ROOT_OPTION, options2, POLL = 5000;
+var init_bump = __esm(() => {
+  init_src();
+  init_progress();
+  init_config2();
+  init_consumers();
+  init_registry();
+  ROOT_OPTION = { type: "string", description: "the folder holding the repositories (~/Workspace)" };
+  options2 = {
+    root: ROOT_OPTION,
+    timeout: { type: "string", short: "t", description: "how long to wait for the registry (10m): 30s, 5m, 1h" },
+    "dry-run": { type: "boolean", description: "print what would run, changing nothing" }
+  };
+});
+
+// src/commands/consumers.ts
+var exports_consumers = {};
+__export(exports_consumers, {
+  consumers: () => consumers
+});
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+function consumers(args) {
+  const { values, positionals: [name] } = parse(args, usage3, options3, { positionals: ["<name>"] });
+  const root = values.root ?? join4(homedir3(), "Workspace");
+  const found = findConsumers(name, root);
+  if (values.json === true)
+    printJson(found);
+  else if (found.length === 0)
+    console.log(`nothing under ${root} depends on ${name}`);
+  else
+    console.log(table([["FOLDER", "KIND", "VERSION", "MANAGER"], ...found.map((each) => [each.dir, each.kind, each.spec, each.manager])], { header: true }));
+  return 0;
+}
+var usage3 = `pkg consumers <name>
+
+Lists the folders under --root whose package.json depends on the package: the folder, the kind of dependency, the version it asks for and the manager its lockfile pins.`, options3;
+var init_consumers2 = __esm(() => {
+  init_src();
+  init_consumers();
+  init_bump();
+  options3 = {
+    root: ROOT_OPTION,
+    json: jsonOption("[{dir, path, kind, spec, manager}]")
+  };
+});
+
+// src/cli.ts
+init_src();
+import process9 from "process";
+// package.json
+var version = "0.3.0";
+
+// src/cli.ts
+process9.exitCode = await runCli({
+  name: "pkg",
+  version,
+  about: "checks npm packages before they are added, and moves a lib's consumers onto a new release",
+  defaultCommand: "check",
+  commands: {
+    check: { summary: "check packages before they are added (`pkg <name>` alone runs it)", run: async (args) => (await Promise.resolve().then(() => (init_check(), exports_check))).check(args) },
+    bump: { summary: "wait for a release on the registry, then bun add it in every consumer", run: async (args) => (await Promise.resolve().then(() => (init_bump(), exports_bump))).bump(args) },
+    consumers: { summary: "list the folders depending on a package, with the version each asks for", run: async (args) => (await Promise.resolve().then(() => (init_consumers2(), exports_consumers))).consumers(args) }
+  }
+});