@kaynooo/pkg-tools 0.0.0-stage → 0.2.1

package/dist/cli.js

@@ -0,0 +1,1355 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import process7 from "process";
+
+// ../kit/src/args.ts
+import process3 from "process";
+import { parseArgs } from "util";
+
+// ../kit/src/format.ts
+import process2 from "process";
+
+// ../kit/src/style.ts
+import process from "process";
+
+// ../../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))];
+}
+var m = (s) => s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+var p = (s) => s <= 0.0031308 ? 12.92 * s : 1.055 * s ** 0.4166666666666667 - 0.055;
+var i = (s, r) => Math.round(s * 10 ** r) / 10 ** r;
+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;
+  }
+}
+
+// ../../node_modules/.bun/@kaynooo+utils@2.31.0+d0769e28dc4dad16/node_modules/@kaynooo/utils/dist/chunk-y1msbssb.js
+var r = 39;
+var o = 49;
+var f2 = "\x1B[";
+var 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] };
+var b = new Set(["", "1", "2", "3", "true"]);
+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 t = le();
+
+// ../kit/src/style.ts
+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 });
+}
+var 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 }
+};
+var STATUS_OF = new Map(Object.entries(STATUSES).flatMap(([status, { words }]) => words.map((word) => [word, status])));
+
+// ../kit/src/format.ts
+var UNITS = [["d", 86400], ["h", 3600], ["m", 60], ["s", 1]];
+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 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`;
+}
+var LINE_BREAKS = /\s*\n\s*/g;
+var ESCAPE = String.fromCharCode(27);
+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));
+}
+
+// ../kit/src/args.ts
+function jsonOption(holds) {
+  return { type: "boolean", description: holds === undefined ? "print JSON" : `print JSON: ${holds}` };
+}
+
+class Exit extends Error {
+  code;
+  hint;
+  constructor(message, code, hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+  }
+}
+function fail(message, code = 2, hint) {
+  throw new Exit(message, code, hint);
+}
+
+class UsageError extends Exit {
+  constructor(message) {
+    super(message, 2);
+  }
+}
+function badUsage(message) {
+  throw new UsageError(message);
+}
+
+class HelpShown extends Exit {
+  constructor() {
+    super("help shown", 0);
+  }
+}
+
+class Completing {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+}
+var completion = { active: false };
+var OPTIONAL = /\[[^\]]+\]/g;
+var USAGE_PREFIX = /^usage:\s*/i;
+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)) {
+  return [usageLine(usage, colors), "", colors.bold("Options:"), ...optionRows(options, colors)].join(`
+`);
+}
+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 parse(args, usage, options, settings = {}) {
+  const all = { ...options, 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));
+  }
+  if (parsed.values.help === true) {
+    console.log(helpText(usage, all));
+    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;
+}
+// ../kit/src/cli.ts
+import process4 from "process";
+
+// ../kit/src/text.ts
+var ANSI = new RegExp(`${String.fromCharCode(27)}\\[[\\d;?]*[a-z]`, "gi");
+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;
+}
+
+// ../kit/src/cli.ts
+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;
+}
+var COMPLETE = "__complete";
+var FILES = "__files__";
+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 printCandidates(found) {
+  for (const line of await found)
+    console.log(line);
+  return 0;
+}
+async function runMain({ name, version, run, redact }, argv = process4.argv.slice(2)) {
+  if (argv[0] === COMPLETE)
+    return printCandidates(leafCandidates(run, argv.slice(1)));
+  if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
+    console.log(version);
+    return 0;
+  }
+  try {
+    return await run(argv);
+  } catch (error) {
+    return reportThrown(name, error, redact);
+  }
+}
+// package.json
+var version = "0.2.1";
+
+// src/popular.json
+var 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
+var SEPARATORS = /[-_.]/g;
+var MIN_LENGTH = 5;
+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);
+}
+
+// src/analyze.ts
+var DEFAULT_MIN_AGE_DAYS = 14;
+var DAY = 86400000;
+var INSTALL_SCRIPTS = ["preinstall", "install", "postinstall"];
+var GIT_PREFIX = /^git\+/;
+var VERSION_SEPARATOR = /(?<=.)@/;
+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;
+}
+
+// src/config.ts
+import { homedir } from "os";
+import { dirname, join } from "path";
+import process6 from "process";
+
+// src/registry.ts
+var PUBLIC_REGISTRY = "https://registry.npmjs.org";
+var DOWNLOADS_API = "https://api.npmjs.org/downloads/point/last-week";
+var TRAILING_SLASHES = /\/+$/;
+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;
+}
+
+// src/config.ts
+var ENV_REFERENCE = /\$\{(\w+)\}|\$(\w+)/g;
+var COMMENT = /^\s*[#;]/;
+var SCOPE_REGISTRY = /^(@[^:]+):registry$/;
+var AUTH_TOKEN = /^(\/\/.+?):_authToken$/;
+var PROTOCOL = /^\w+:/;
+var QUOTES = /^(["'])(.*)\1$/;
+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 = process6.cwd(), env = process6.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;
+}
+
+// src/commands/check.ts
+var usage = `pkg <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.`;
+var options = {
+  json: jsonOption(),
+  "min-age": { type: "string", description: `days a version must be old (${DEFAULT_MIN_AGE_DAYS})` }
+};
+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;
+}
+
+// src/cli.ts
+process7.exitCode = await runMain({ name: "pkg", version, run: check });