create-cloudflare 2.9.1 → 2.9.2

package/dist/cli.js

@@ -33,12 +33,1555 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/.pnpm/escape-string-regexp@1.0.5/node_modules/escape-string-regexp/index.js
+var require_escape_string_regexp = __commonJS({
+  "../../node_modules/.pnpm/escape-string-regexp@1.0.5/node_modules/escape-string-regexp/index.js"(exports2, module2) {
+    "use strict";
+    var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+    module2.exports = function(str) {
+      if (typeof str !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      return str.replace(matchOperatorsRe, "\\$&");
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/color-name@1.1.3/node_modules/color-name/index.js
+var require_color_name = __commonJS({
+  "../../node_modules/.pnpm/color-name@1.1.3/node_modules/color-name/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      "aliceblue": [240, 248, 255],
+      "antiquewhite": [250, 235, 215],
+      "aqua": [0, 255, 255],
+      "aquamarine": [127, 255, 212],
+      "azure": [240, 255, 255],
+      "beige": [245, 245, 220],
+      "bisque": [255, 228, 196],
+      "black": [0, 0, 0],
+      "blanchedalmond": [255, 235, 205],
+      "blue": [0, 0, 255],
+      "blueviolet": [138, 43, 226],
+      "brown": [165, 42, 42],
+      "burlywood": [222, 184, 135],
+      "cadetblue": [95, 158, 160],
+      "chartreuse": [127, 255, 0],
+      "chocolate": [210, 105, 30],
+      "coral": [255, 127, 80],
+      "cornflowerblue": [100, 149, 237],
+      "cornsilk": [255, 248, 220],
+      "crimson": [220, 20, 60],
+      "cyan": [0, 255, 255],
+      "darkblue": [0, 0, 139],
+      "darkcyan": [0, 139, 139],
+      "darkgoldenrod": [184, 134, 11],
+      "darkgray": [169, 169, 169],
+      "darkgreen": [0, 100, 0],
+      "darkgrey": [169, 169, 169],
+      "darkkhaki": [189, 183, 107],
+      "darkmagenta": [139, 0, 139],
+      "darkolivegreen": [85, 107, 47],
+      "darkorange": [255, 140, 0],
+      "darkorchid": [153, 50, 204],
+      "darkred": [139, 0, 0],
+      "darksalmon": [233, 150, 122],
+      "darkseagreen": [143, 188, 143],
+      "darkslateblue": [72, 61, 139],
+      "darkslategray": [47, 79, 79],
+      "darkslategrey": [47, 79, 79],
+      "darkturquoise": [0, 206, 209],
+      "darkviolet": [148, 0, 211],
+      "deeppink": [255, 20, 147],
+      "deepskyblue": [0, 191, 255],
+      "dimgray": [105, 105, 105],
+      "dimgrey": [105, 105, 105],
+      "dodgerblue": [30, 144, 255],
+      "firebrick": [178, 34, 34],
+      "floralwhite": [255, 250, 240],
+      "forestgreen": [34, 139, 34],
+      "fuchsia": [255, 0, 255],
+      "gainsboro": [220, 220, 220],
+      "ghostwhite": [248, 248, 255],
+      "gold": [255, 215, 0],
+      "goldenrod": [218, 165, 32],
+      "gray": [128, 128, 128],
+      "green": [0, 128, 0],
+      "greenyellow": [173, 255, 47],
+      "grey": [128, 128, 128],
+      "honeydew": [240, 255, 240],
+      "hotpink": [255, 105, 180],
+      "indianred": [205, 92, 92],
+      "indigo": [75, 0, 130],
+      "ivory": [255, 255, 240],
+      "khaki": [240, 230, 140],
+      "lavender": [230, 230, 250],
+      "lavenderblush": [255, 240, 245],
+      "lawngreen": [124, 252, 0],
+      "lemonchiffon": [255, 250, 205],
+      "lightblue": [173, 216, 230],
+      "lightcoral": [240, 128, 128],
+      "lightcyan": [224, 255, 255],
+      "lightgoldenrodyellow": [250, 250, 210],
+      "lightgray": [211, 211, 211],
+      "lightgreen": [144, 238, 144],
+      "lightgrey": [211, 211, 211],
+      "lightpink": [255, 182, 193],
+      "lightsalmon": [255, 160, 122],
+      "lightseagreen": [32, 178, 170],
+      "lightskyblue": [135, 206, 250],
+      "lightslategray": [119, 136, 153],
+      "lightslategrey": [119, 136, 153],
+      "lightsteelblue": [176, 196, 222],
+      "lightyellow": [255, 255, 224],
+      "lime": [0, 255, 0],
+      "limegreen": [50, 205, 50],
+      "linen": [250, 240, 230],
+      "magenta": [255, 0, 255],
+      "maroon": [128, 0, 0],
+      "mediumaquamarine": [102, 205, 170],
+      "mediumblue": [0, 0, 205],
+      "mediumorchid": [186, 85, 211],
+      "mediumpurple": [147, 112, 219],
+      "mediumseagreen": [60, 179, 113],
+      "mediumslateblue": [123, 104, 238],
+      "mediumspringgreen": [0, 250, 154],
+      "mediumturquoise": [72, 209, 204],
+      "mediumvioletred": [199, 21, 133],
+      "midnightblue": [25, 25, 112],
+      "mintcream": [245, 255, 250],
+      "mistyrose": [255, 228, 225],
+      "moccasin": [255, 228, 181],
+      "navajowhite": [255, 222, 173],
+      "navy": [0, 0, 128],
+      "oldlace": [253, 245, 230],
+      "olive": [128, 128, 0],
+      "olivedrab": [107, 142, 35],
+      "orange": [255, 165, 0],
+      "orangered": [255, 69, 0],
+      "orchid": [218, 112, 214],
+      "palegoldenrod": [238, 232, 170],
+      "palegreen": [152, 251, 152],
+      "paleturquoise": [175, 238, 238],
+      "palevioletred": [219, 112, 147],
+      "papayawhip": [255, 239, 213],
+      "peachpuff": [255, 218, 185],
+      "peru": [205, 133, 63],
+      "pink": [255, 192, 203],
+      "plum": [221, 160, 221],
+      "powderblue": [176, 224, 230],
+      "purple": [128, 0, 128],
+      "rebeccapurple": [102, 51, 153],
+      "red": [255, 0, 0],
+      "rosybrown": [188, 143, 143],
+      "royalblue": [65, 105, 225],
+      "saddlebrown": [139, 69, 19],
+      "salmon": [250, 128, 114],
+      "sandybrown": [244, 164, 96],
+      "seagreen": [46, 139, 87],
+      "seashell": [255, 245, 238],
+      "sienna": [160, 82, 45],
+      "silver": [192, 192, 192],
+      "skyblue": [135, 206, 235],
+      "slateblue": [106, 90, 205],
+      "slategray": [112, 128, 144],
+      "slategrey": [112, 128, 144],
+      "snow": [255, 250, 250],
+      "springgreen": [0, 255, 127],
+      "steelblue": [70, 130, 180],
+      "tan": [210, 180, 140],
+      "teal": [0, 128, 128],
+      "thistle": [216, 191, 216],
+      "tomato": [255, 99, 71],
+      "turquoise": [64, 224, 208],
+      "violet": [238, 130, 238],
+      "wheat": [245, 222, 179],
+      "white": [255, 255, 255],
+      "whitesmoke": [245, 245, 245],
+      "yellow": [255, 255, 0],
+      "yellowgreen": [154, 205, 50]
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/conversions.js
+var require_conversions = __commonJS({
+  "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/conversions.js"(exports2, module2) {
+    var cssKeywords = require_color_name();
+    var reverseKeywords = {};
+    for (key in cssKeywords) {
+      if (cssKeywords.hasOwnProperty(key)) {
+        reverseKeywords[cssKeywords[key]] = key;
+      }
+    }
+    var key;
+    var convert = module2.exports = {
+      rgb: { channels: 3, labels: "rgb" },
+      hsl: { channels: 3, labels: "hsl" },
+      hsv: { channels: 3, labels: "hsv" },
+      hwb: { channels: 3, labels: "hwb" },
+      cmyk: { channels: 4, labels: "cmyk" },
+      xyz: { channels: 3, labels: "xyz" },
+      lab: { channels: 3, labels: "lab" },
+      lch: { channels: 3, labels: "lch" },
+      hex: { channels: 1, labels: ["hex"] },
+      keyword: { channels: 1, labels: ["keyword"] },
+      ansi16: { channels: 1, labels: ["ansi16"] },
+      ansi256: { channels: 1, labels: ["ansi256"] },
+      hcg: { channels: 3, labels: ["h", "c", "g"] },
+      apple: { channels: 3, labels: ["r16", "g16", "b16"] },
+      gray: { channels: 1, labels: ["gray"] }
+    };
+    for (model in convert) {
+      if (convert.hasOwnProperty(model)) {
+        if (!("channels" in convert[model])) {
+          throw new Error("missing channels property: " + model);
+        }
+        if (!("labels" in convert[model])) {
+          throw new Error("missing channel labels property: " + model);
+        }
+        if (convert[model].labels.length !== convert[model].channels) {
+          throw new Error("channel and label counts mismatch: " + model);
+        }
+        channels = convert[model].channels;
+        labels = convert[model].labels;
+        delete convert[model].channels;
+        delete convert[model].labels;
+        Object.defineProperty(convert[model], "channels", { value: channels });
+        Object.defineProperty(convert[model], "labels", { value: labels });
+      }
+    }
+    var channels;
+    var labels;
+    var model;
+    convert.rgb.hsl = function(rgb) {
+      var r2 = rgb[0] / 255;
+      var g2 = rgb[1] / 255;
+      var b2 = rgb[2] / 255;
+      var min = Math.min(r2, g2, b2);
+      var max = Math.max(r2, g2, b2);
+      var delta = max - min;
+      var h2;
+      var s;
+      var l2;
+      if (max === min) {
+        h2 = 0;
+      } else if (r2 === max) {
+        h2 = (g2 - b2) / delta;
+      } else if (g2 === max) {
+        h2 = 2 + (b2 - r2) / delta;
+      } else if (b2 === max) {
+        h2 = 4 + (r2 - g2) / delta;
+      }
+      h2 = Math.min(h2 * 60, 360);
+      if (h2 < 0) {
+        h2 += 360;
+      }
+      l2 = (min + max) / 2;
+      if (max === min) {
+        s = 0;
+      } else if (l2 <= 0.5) {
+        s = delta / (max + min);
+      } else {
+        s = delta / (2 - max - min);
+      }
+      return [h2, s * 100, l2 * 100];
+    };
+    convert.rgb.hsv = function(rgb) {
+      var rdif;
+      var gdif;
+      var bdif;
+      var h2;
+      var s;
+      var r2 = rgb[0] / 255;
+      var g2 = rgb[1] / 255;
+      var b2 = rgb[2] / 255;
+      var v2 = Math.max(r2, g2, b2);
+      var diff = v2 - Math.min(r2, g2, b2);
+      var diffc = function(c2) {
+        return (v2 - c2) / 6 / diff + 1 / 2;
+      };
+      if (diff === 0) {
+        h2 = s = 0;
+      } else {
+        s = diff / v2;
+        rdif = diffc(r2);
+        gdif = diffc(g2);
+        bdif = diffc(b2);
+        if (r2 === v2) {
+          h2 = bdif - gdif;
+        } else if (g2 === v2) {
+          h2 = 1 / 3 + rdif - bdif;
+        } else if (b2 === v2) {
+          h2 = 2 / 3 + gdif - rdif;
+        }
+        if (h2 < 0) {
+          h2 += 1;
+        } else if (h2 > 1) {
+          h2 -= 1;
+        }
+      }
+      return [
+        h2 * 360,
+        s * 100,
+        v2 * 100
+      ];
+    };
+    convert.rgb.hwb = function(rgb) {
+      var r2 = rgb[0];
+      var g2 = rgb[1];
+      var b2 = rgb[2];
+      var h2 = convert.rgb.hsl(rgb)[0];
+      var w2 = 1 / 255 * Math.min(r2, Math.min(g2, b2));
+      b2 = 1 - 1 / 255 * Math.max(r2, Math.max(g2, b2));
+      return [h2, w2 * 100, b2 * 100];
+    };
+    convert.rgb.cmyk = function(rgb) {
+      var r2 = rgb[0] / 255;
+      var g2 = rgb[1] / 255;
+      var b2 = rgb[2] / 255;
+      var c2;
+      var m2;
+      var y2;
+      var k2;
+      k2 = Math.min(1 - r2, 1 - g2, 1 - b2);
+      c2 = (1 - r2 - k2) / (1 - k2) || 0;
+      m2 = (1 - g2 - k2) / (1 - k2) || 0;
+      y2 = (1 - b2 - k2) / (1 - k2) || 0;
+      return [c2 * 100, m2 * 100, y2 * 100, k2 * 100];
+    };
+    function comparativeDistance(x2, y2) {
+      return Math.pow(x2[0] - y2[0], 2) + Math.pow(x2[1] - y2[1], 2) + Math.pow(x2[2] - y2[2], 2);
+    }
+    convert.rgb.keyword = function(rgb) {
+      var reversed = reverseKeywords[rgb];
+      if (reversed) {
+        return reversed;
+      }
+      var currentClosestDistance = Infinity;
+      var currentClosestKeyword;
+      for (var keyword in cssKeywords) {
+        if (cssKeywords.hasOwnProperty(keyword)) {
+          var value = cssKeywords[keyword];
+          var distance = comparativeDistance(rgb, value);
+          if (distance < currentClosestDistance) {
+            currentClosestDistance = distance;
+            currentClosestKeyword = keyword;
+          }
+        }
+      }
+      return currentClosestKeyword;
+    };
+    convert.keyword.rgb = function(keyword) {
+      return cssKeywords[keyword];
+    };
+    convert.rgb.xyz = function(rgb) {
+      var r2 = rgb[0] / 255;
+      var g2 = rgb[1] / 255;
+      var b2 = rgb[2] / 255;
+      r2 = r2 > 0.04045 ? Math.pow((r2 + 0.055) / 1.055, 2.4) : r2 / 12.92;
+      g2 = g2 > 0.04045 ? Math.pow((g2 + 0.055) / 1.055, 2.4) : g2 / 12.92;
+      b2 = b2 > 0.04045 ? Math.pow((b2 + 0.055) / 1.055, 2.4) : b2 / 12.92;
+      var x2 = r2 * 0.4124 + g2 * 0.3576 + b2 * 0.1805;
+      var y2 = r2 * 0.2126 + g2 * 0.7152 + b2 * 0.0722;
+      var z2 = r2 * 0.0193 + g2 * 0.1192 + b2 * 0.9505;
+      return [x2 * 100, y2 * 100, z2 * 100];
+    };
+    convert.rgb.lab = function(rgb) {
+      var xyz = convert.rgb.xyz(rgb);
+      var x2 = xyz[0];
+      var y2 = xyz[1];
+      var z2 = xyz[2];
+      var l2;
+      var a;
+      var b2;
+      x2 /= 95.047;
+      y2 /= 100;
+      z2 /= 108.883;
+      x2 = x2 > 8856e-6 ? Math.pow(x2, 1 / 3) : 7.787 * x2 + 16 / 116;
+      y2 = y2 > 8856e-6 ? Math.pow(y2, 1 / 3) : 7.787 * y2 + 16 / 116;
+      z2 = z2 > 8856e-6 ? Math.pow(z2, 1 / 3) : 7.787 * z2 + 16 / 116;
+      l2 = 116 * y2 - 16;
+      a = 500 * (x2 - y2);
+      b2 = 200 * (y2 - z2);
+      return [l2, a, b2];
+    };
+    convert.hsl.rgb = function(hsl) {
+      var h2 = hsl[0] / 360;
+      var s = hsl[1] / 100;
+      var l2 = hsl[2] / 100;
+      var t1;
+      var t2;
+      var t3;
+      var rgb;
+      var val;
+      if (s === 0) {
+        val = l2 * 255;
+        return [val, val, val];
+      }
+      if (l2 < 0.5) {
+        t2 = l2 * (1 + s);
+      } else {
+        t2 = l2 + s - l2 * s;
+      }
+      t1 = 2 * l2 - t2;
+      rgb = [0, 0, 0];
+      for (var i = 0; i < 3; i++) {
+        t3 = h2 + 1 / 3 * -(i - 1);
+        if (t3 < 0) {
+          t3++;
+        }
+        if (t3 > 1) {
+          t3--;
+        }
+        if (6 * t3 < 1) {
+          val = t1 + (t2 - t1) * 6 * t3;
+        } else if (2 * t3 < 1) {
+          val = t2;
+        } else if (3 * t3 < 2) {
+          val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+        } else {
+          val = t1;
+        }
+        rgb[i] = val * 255;
+      }
+      return rgb;
+    };
+    convert.hsl.hsv = function(hsl) {
+      var h2 = hsl[0];
+      var s = hsl[1] / 100;
+      var l2 = hsl[2] / 100;
+      var smin = s;
+      var lmin = Math.max(l2, 0.01);
+      var sv;
+      var v2;
+      l2 *= 2;
+      s *= l2 <= 1 ? l2 : 2 - l2;
+      smin *= lmin <= 1 ? lmin : 2 - lmin;
+      v2 = (l2 + s) / 2;
+      sv = l2 === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l2 + s);
+      return [h2, sv * 100, v2 * 100];
+    };
+    convert.hsv.rgb = function(hsv) {
+      var h2 = hsv[0] / 60;
+      var s = hsv[1] / 100;
+      var v2 = hsv[2] / 100;
+      var hi = Math.floor(h2) % 6;
+      var f = h2 - Math.floor(h2);
+      var p2 = 255 * v2 * (1 - s);
+      var q2 = 255 * v2 * (1 - s * f);
+      var t = 255 * v2 * (1 - s * (1 - f));
+      v2 *= 255;
+      switch (hi) {
+        case 0:
+          return [v2, t, p2];
+        case 1:
+          return [q2, v2, p2];
+        case 2:
+          return [p2, v2, t];
+        case 3:
+          return [p2, q2, v2];
+        case 4:
+          return [t, p2, v2];
+        case 5:
+          return [v2, p2, q2];
+      }
+    };
+    convert.hsv.hsl = function(hsv) {
+      var h2 = hsv[0];
+      var s = hsv[1] / 100;
+      var v2 = hsv[2] / 100;
+      var vmin = Math.max(v2, 0.01);
+      var lmin;
+      var sl;
+      var l2;
+      l2 = (2 - s) * v2;
+      lmin = (2 - s) * vmin;
+      sl = s * vmin;
+      sl /= lmin <= 1 ? lmin : 2 - lmin;
+      sl = sl || 0;
+      l2 /= 2;
+      return [h2, sl * 100, l2 * 100];
+    };
+    convert.hwb.rgb = function(hwb) {
+      var h2 = hwb[0] / 360;
+      var wh = hwb[1] / 100;
+      var bl = hwb[2] / 100;
+      var ratio = wh + bl;
+      var i;
+      var v2;
+      var f;
+      var n;
+      if (ratio > 1) {
+        wh /= ratio;
+        bl /= ratio;
+      }
+      i = Math.floor(6 * h2);
+      v2 = 1 - bl;
+      f = 6 * h2 - i;
+      if ((i & 1) !== 0) {
+        f = 1 - f;
+      }
+      n = wh + f * (v2 - wh);
+      var r2;
+      var g2;
+      var b2;
+      switch (i) {
+        default:
+        case 6:
+        case 0:
+          r2 = v2;
+          g2 = n;
+          b2 = wh;
+          break;
+        case 1:
+          r2 = n;
+          g2 = v2;
+          b2 = wh;
+          break;
+        case 2:
+          r2 = wh;
+          g2 = v2;
+          b2 = n;
+          break;
+        case 3:
+          r2 = wh;
+          g2 = n;
+          b2 = v2;
+          break;
+        case 4:
+          r2 = n;
+          g2 = wh;
+          b2 = v2;
+          break;
+        case 5:
+          r2 = v2;
+          g2 = wh;
+          b2 = n;
+          break;
+      }
+      return [r2 * 255, g2 * 255, b2 * 255];
+    };
+    convert.cmyk.rgb = function(cmyk) {
+      var c2 = cmyk[0] / 100;
+      var m2 = cmyk[1] / 100;
+      var y2 = cmyk[2] / 100;
+      var k2 = cmyk[3] / 100;
+      var r2;
+      var g2;
+      var b2;
+      r2 = 1 - Math.min(1, c2 * (1 - k2) + k2);
+      g2 = 1 - Math.min(1, m2 * (1 - k2) + k2);
+      b2 = 1 - Math.min(1, y2 * (1 - k2) + k2);
+      return [r2 * 255, g2 * 255, b2 * 255];
+    };
+    convert.xyz.rgb = function(xyz) {
+      var x2 = xyz[0] / 100;
+      var y2 = xyz[1] / 100;
+      var z2 = xyz[2] / 100;
+      var r2;
+      var g2;
+      var b2;
+      r2 = x2 * 3.2406 + y2 * -1.5372 + z2 * -0.4986;
+      g2 = x2 * -0.9689 + y2 * 1.8758 + z2 * 0.0415;
+      b2 = x2 * 0.0557 + y2 * -0.204 + z2 * 1.057;
+      r2 = r2 > 31308e-7 ? 1.055 * Math.pow(r2, 1 / 2.4) - 0.055 : r2 * 12.92;
+      g2 = g2 > 31308e-7 ? 1.055 * Math.pow(g2, 1 / 2.4) - 0.055 : g2 * 12.92;
+      b2 = b2 > 31308e-7 ? 1.055 * Math.pow(b2, 1 / 2.4) - 0.055 : b2 * 12.92;
+      r2 = Math.min(Math.max(0, r2), 1);
+      g2 = Math.min(Math.max(0, g2), 1);
+      b2 = Math.min(Math.max(0, b2), 1);
+      return [r2 * 255, g2 * 255, b2 * 255];
+    };
+    convert.xyz.lab = function(xyz) {
+      var x2 = xyz[0];
+      var y2 = xyz[1];
+      var z2 = xyz[2];
+      var l2;
+      var a;
+      var b2;
+      x2 /= 95.047;
+      y2 /= 100;
+      z2 /= 108.883;
+      x2 = x2 > 8856e-6 ? Math.pow(x2, 1 / 3) : 7.787 * x2 + 16 / 116;
+      y2 = y2 > 8856e-6 ? Math.pow(y2, 1 / 3) : 7.787 * y2 + 16 / 116;
+      z2 = z2 > 8856e-6 ? Math.pow(z2, 1 / 3) : 7.787 * z2 + 16 / 116;
+      l2 = 116 * y2 - 16;
+      a = 500 * (x2 - y2);
+      b2 = 200 * (y2 - z2);
+      return [l2, a, b2];
+    };
+    convert.lab.xyz = function(lab) {
+      var l2 = lab[0];
+      var a = lab[1];
+      var b2 = lab[2];
+      var x2;
+      var y2;
+      var z2;
+      y2 = (l2 + 16) / 116;
+      x2 = a / 500 + y2;
+      z2 = y2 - b2 / 200;
+      var y22 = Math.pow(y2, 3);
+      var x22 = Math.pow(x2, 3);
+      var z22 = Math.pow(z2, 3);
+      y2 = y22 > 8856e-6 ? y22 : (y2 - 16 / 116) / 7.787;
+      x2 = x22 > 8856e-6 ? x22 : (x2 - 16 / 116) / 7.787;
+      z2 = z22 > 8856e-6 ? z22 : (z2 - 16 / 116) / 7.787;
+      x2 *= 95.047;
+      y2 *= 100;
+      z2 *= 108.883;
+      return [x2, y2, z2];
+    };
+    convert.lab.lch = function(lab) {
+      var l2 = lab[0];
+      var a = lab[1];
+      var b2 = lab[2];
+      var hr;
+      var h2;
+      var c2;
+      hr = Math.atan2(b2, a);
+      h2 = hr * 360 / 2 / Math.PI;
+      if (h2 < 0) {
+        h2 += 360;
+      }
+      c2 = Math.sqrt(a * a + b2 * b2);
+      return [l2, c2, h2];
+    };
+    convert.lch.lab = function(lch) {
+      var l2 = lch[0];
+      var c2 = lch[1];
+      var h2 = lch[2];
+      var a;
+      var b2;
+      var hr;
+      hr = h2 / 360 * 2 * Math.PI;
+      a = c2 * Math.cos(hr);
+      b2 = c2 * Math.sin(hr);
+      return [l2, a, b2];
+    };
+    convert.rgb.ansi16 = function(args) {
+      var r2 = args[0];
+      var g2 = args[1];
+      var b2 = args[2];
+      var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2];
+      value = Math.round(value / 50);
+      if (value === 0) {
+        return 30;
+      }
+      var ansi2 = 30 + (Math.round(b2 / 255) << 2 | Math.round(g2 / 255) << 1 | Math.round(r2 / 255));
+      if (value === 2) {
+        ansi2 += 60;
+      }
+      return ansi2;
+    };
+    convert.hsv.ansi16 = function(args) {
+      return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+    };
+    convert.rgb.ansi256 = function(args) {
+      var r2 = args[0];
+      var g2 = args[1];
+      var b2 = args[2];
+      if (r2 === g2 && g2 === b2) {
+        if (r2 < 8) {
+          return 16;
+        }
+        if (r2 > 248) {
+          return 231;
+        }
+        return Math.round((r2 - 8) / 247 * 24) + 232;
+      }
+      var ansi2 = 16 + 36 * Math.round(r2 / 255 * 5) + 6 * Math.round(g2 / 255 * 5) + Math.round(b2 / 255 * 5);
+      return ansi2;
+    };
+    convert.ansi16.rgb = function(args) {
+      var color = args % 10;
+      if (color === 0 || color === 7) {
+        if (args > 50) {
+          color += 3.5;
+        }
+        color = color / 10.5 * 255;
+        return [color, color, color];
+      }
+      var mult = (~~(args > 50) + 1) * 0.5;
+      var r2 = (color & 1) * mult * 255;
+      var g2 = (color >> 1 & 1) * mult * 255;
+      var b2 = (color >> 2 & 1) * mult * 255;
+      return [r2, g2, b2];
+    };
+    convert.ansi256.rgb = function(args) {
+      if (args >= 232) {
+        var c2 = (args - 232) * 10 + 8;
+        return [c2, c2, c2];
+      }
+      args -= 16;
+      var rem;
+      var r2 = Math.floor(args / 36) / 5 * 255;
+      var g2 = Math.floor((rem = args % 36) / 6) / 5 * 255;
+      var b2 = rem % 6 / 5 * 255;
+      return [r2, g2, b2];
+    };
+    convert.rgb.hex = function(args) {
+      var integer = ((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255);
+      var string = integer.toString(16).toUpperCase();
+      return "000000".substring(string.length) + string;
+    };
+    convert.hex.rgb = function(args) {
+      var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+      if (!match) {
+        return [0, 0, 0];
+      }
+      var colorString = match[0];
+      if (match[0].length === 3) {
+        colorString = colorString.split("").map(function(char) {
+          return char + char;
+        }).join("");
+      }
+      var integer = parseInt(colorString, 16);
+      var r2 = integer >> 16 & 255;
+      var g2 = integer >> 8 & 255;
+      var b2 = integer & 255;
+      return [r2, g2, b2];
+    };
+    convert.rgb.hcg = function(rgb) {
+      var r2 = rgb[0] / 255;
+      var g2 = rgb[1] / 255;
+      var b2 = rgb[2] / 255;
+      var max = Math.max(Math.max(r2, g2), b2);
+      var min = Math.min(Math.min(r2, g2), b2);
+      var chroma = max - min;
+      var grayscale;
+      var hue;
+      if (chroma < 1) {
+        grayscale = min / (1 - chroma);
+      } else {
+        grayscale = 0;
+      }
+      if (chroma <= 0) {
+        hue = 0;
+      } else if (max === r2) {
+        hue = (g2 - b2) / chroma % 6;
+      } else if (max === g2) {
+        hue = 2 + (b2 - r2) / chroma;
+      } else {
+        hue = 4 + (r2 - g2) / chroma + 4;
+      }
+      hue /= 6;
+      hue %= 1;
+      return [hue * 360, chroma * 100, grayscale * 100];
+    };
+    convert.hsl.hcg = function(hsl) {
+      var s = hsl[1] / 100;
+      var l2 = hsl[2] / 100;
+      var c2 = 1;
+      var f = 0;
+      if (l2 < 0.5) {
+        c2 = 2 * s * l2;
+      } else {
+        c2 = 2 * s * (1 - l2);
+      }
+      if (c2 < 1) {
+        f = (l2 - 0.5 * c2) / (1 - c2);
+      }
+      return [hsl[0], c2 * 100, f * 100];
+    };
+    convert.hsv.hcg = function(hsv) {
+      var s = hsv[1] / 100;
+      var v2 = hsv[2] / 100;
+      var c2 = s * v2;
+      var f = 0;
+      if (c2 < 1) {
+        f = (v2 - c2) / (1 - c2);
+      }
+      return [hsv[0], c2 * 100, f * 100];
+    };
+    convert.hcg.rgb = function(hcg) {
+      var h2 = hcg[0] / 360;
+      var c2 = hcg[1] / 100;
+      var g2 = hcg[2] / 100;
+      if (c2 === 0) {
+        return [g2 * 255, g2 * 255, g2 * 255];
+      }
+      var pure = [0, 0, 0];
+      var hi = h2 % 1 * 6;
+      var v2 = hi % 1;
+      var w2 = 1 - v2;
+      var mg = 0;
+      switch (Math.floor(hi)) {
+        case 0:
+          pure[0] = 1;
+          pure[1] = v2;
+          pure[2] = 0;
+          break;
+        case 1:
+          pure[0] = w2;
+          pure[1] = 1;
+          pure[2] = 0;
+          break;
+        case 2:
+          pure[0] = 0;
+          pure[1] = 1;
+          pure[2] = v2;
+          break;
+        case 3:
+          pure[0] = 0;
+          pure[1] = w2;
+          pure[2] = 1;
+          break;
+        case 4:
+          pure[0] = v2;
+          pure[1] = 0;
+          pure[2] = 1;
+          break;
+        default:
+          pure[0] = 1;
+          pure[1] = 0;
+          pure[2] = w2;
+      }
+      mg = (1 - c2) * g2;
+      return [
+        (c2 * pure[0] + mg) * 255,
+        (c2 * pure[1] + mg) * 255,
+        (c2 * pure[2] + mg) * 255
+      ];
+    };
+    convert.hcg.hsv = function(hcg) {
+      var c2 = hcg[1] / 100;
+      var g2 = hcg[2] / 100;
+      var v2 = c2 + g2 * (1 - c2);
+      var f = 0;
+      if (v2 > 0) {
+        f = c2 / v2;
+      }
+      return [hcg[0], f * 100, v2 * 100];
+    };
+    convert.hcg.hsl = function(hcg) {
+      var c2 = hcg[1] / 100;
+      var g2 = hcg[2] / 100;
+      var l2 = g2 * (1 - c2) + 0.5 * c2;
+      var s = 0;
+      if (l2 > 0 && l2 < 0.5) {
+        s = c2 / (2 * l2);
+      } else if (l2 >= 0.5 && l2 < 1) {
+        s = c2 / (2 * (1 - l2));
+      }
+      return [hcg[0], s * 100, l2 * 100];
+    };
+    convert.hcg.hwb = function(hcg) {
+      var c2 = hcg[1] / 100;
+      var g2 = hcg[2] / 100;
+      var v2 = c2 + g2 * (1 - c2);
+      return [hcg[0], (v2 - c2) * 100, (1 - v2) * 100];
+    };
+    convert.hwb.hcg = function(hwb) {
+      var w2 = hwb[1] / 100;
+      var b2 = hwb[2] / 100;
+      var v2 = 1 - b2;
+      var c2 = v2 - w2;
+      var g2 = 0;
+      if (c2 < 1) {
+        g2 = (v2 - c2) / (1 - c2);
+      }
+      return [hwb[0], c2 * 100, g2 * 100];
+    };
+    convert.apple.rgb = function(apple) {
+      return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
+    };
+    convert.rgb.apple = function(rgb) {
+      return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
+    };
+    convert.gray.rgb = function(args) {
+      return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
+    };
+    convert.gray.hsl = convert.gray.hsv = function(args) {
+      return [0, 0, args[0]];
+    };
+    convert.gray.hwb = function(gray2) {
+      return [0, 100, gray2[0]];
+    };
+    convert.gray.cmyk = function(gray2) {
+      return [0, 0, 0, gray2[0]];
+    };
+    convert.gray.lab = function(gray2) {
+      return [gray2[0], 0, 0];
+    };
+    convert.gray.hex = function(gray2) {
+      var val = Math.round(gray2[0] / 100 * 255) & 255;
+      var integer = (val << 16) + (val << 8) + val;
+      var string = integer.toString(16).toUpperCase();
+      return "000000".substring(string.length) + string;
+    };
+    convert.rgb.gray = function(rgb) {
+      var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
+      return [val / 255 * 100];
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/route.js
+var require_route = __commonJS({
+  "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/route.js"(exports2, module2) {
+    var conversions = require_conversions();
+    function buildGraph() {
+      var graph = {};
+      var models = Object.keys(conversions);
+      for (var len = models.length, i = 0; i < len; i++) {
+        graph[models[i]] = {
+          // http://jsperf.com/1-vs-infinity
+          // micro-opt, but this is simple.
+          distance: -1,
+          parent: null
+        };
+      }
+      return graph;
+    }
+    function deriveBFS(fromModel) {
+      var graph = buildGraph();
+      var queue = [fromModel];
+      graph[fromModel].distance = 0;
+      while (queue.length) {
+        var current = queue.pop();
+        var adjacents = Object.keys(conversions[current]);
+        for (var len = adjacents.length, i = 0; i < len; i++) {
+          var adjacent = adjacents[i];
+          var node = graph[adjacent];
+          if (node.distance === -1) {
+            node.distance = graph[current].distance + 1;
+            node.parent = current;
+            queue.unshift(adjacent);
+          }
+        }
+      }
+      return graph;
+    }
+    function link(from, to) {
+      return function(args) {
+        return to(from(args));
+      };
+    }
+    function wrapConversion(toModel, graph) {
+      var path3 = [graph[toModel].parent, toModel];
+      var fn = conversions[graph[toModel].parent][toModel];
+      var cur = graph[toModel].parent;
+      while (graph[cur].parent) {
+        path3.unshift(graph[cur].parent);
+        fn = link(conversions[graph[cur].parent][cur], fn);
+        cur = graph[cur].parent;
+      }
+      fn.conversion = path3;
+      return fn;
+    }
+    module2.exports = function(fromModel) {
+      var graph = deriveBFS(fromModel);
+      var conversion = {};
+      var models = Object.keys(graph);
+      for (var len = models.length, i = 0; i < len; i++) {
+        var toModel = models[i];
+        var node = graph[toModel];
+        if (node.parent === null) {
+          continue;
+        }
+        conversion[toModel] = wrapConversion(toModel, graph);
+      }
+      return conversion;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/index.js
+var require_color_convert = __commonJS({
+  "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/index.js"(exports2, module2) {
+    var conversions = require_conversions();
+    var route = require_route();
+    var convert = {};
+    var models = Object.keys(conversions);
+    function wrapRaw(fn) {
+      var wrappedFn = function(args) {
+        if (args === void 0 || args === null) {
+          return args;
+        }
+        if (arguments.length > 1) {
+          args = Array.prototype.slice.call(arguments);
+        }
+        return fn(args);
+      };
+      if ("conversion" in fn) {
+        wrappedFn.conversion = fn.conversion;
+      }
+      return wrappedFn;
+    }
+    function wrapRounded(fn) {
+      var wrappedFn = function(args) {
+        if (args === void 0 || args === null) {
+          return args;
+        }
+        if (arguments.length > 1) {
+          args = Array.prototype.slice.call(arguments);
+        }
+        var result = fn(args);
+        if (typeof result === "object") {
+          for (var len = result.length, i = 0; i < len; i++) {
+            result[i] = Math.round(result[i]);
+          }
+        }
+        return result;
+      };
+      if ("conversion" in fn) {
+        wrappedFn.conversion = fn.conversion;
+      }
+      return wrappedFn;
+    }
+    models.forEach(function(fromModel) {
+      convert[fromModel] = {};
+      Object.defineProperty(convert[fromModel], "channels", { value: conversions[fromModel].channels });
+      Object.defineProperty(convert[fromModel], "labels", { value: conversions[fromModel].labels });
+      var routes = route(fromModel);
+      var routeModels = Object.keys(routes);
+      routeModels.forEach(function(toModel) {
+        var fn = routes[toModel];
+        convert[fromModel][toModel] = wrapRounded(fn);
+        convert[fromModel][toModel].raw = wrapRaw(fn);
+      });
+    });
+    module2.exports = convert;
+  }
+});
+
+// ../../node_modules/.pnpm/ansi-styles@3.2.1/node_modules/ansi-styles/index.js
+var require_ansi_styles = __commonJS({
+  "../../node_modules/.pnpm/ansi-styles@3.2.1/node_modules/ansi-styles/index.js"(exports2, module2) {
+    "use strict";
+    var colorConvert = require_color_convert();
+    var wrapAnsi162 = (fn, offset) => function() {
+      const code = fn.apply(colorConvert, arguments);
+      return `\x1B[${code + offset}m`;
+    };
+    var wrapAnsi2562 = (fn, offset) => function() {
+      const code = fn.apply(colorConvert, arguments);
+      return `\x1B[${38 + offset};5;${code}m`;
+    };
+    var wrapAnsi16m2 = (fn, offset) => function() {
+      const rgb = fn.apply(colorConvert, arguments);
+      return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+    };
+    function assembleStyles2() {
+      const codes = /* @__PURE__ */ new Map();
+      const styles2 = {
+        modifier: {
+          reset: [0, 0],
+          // 21 isn't widely supported and 22 does the same thing
+          bold: [1, 22],
+          dim: [2, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          inverse: [7, 27],
+          hidden: [8, 28],
+          strikethrough: [9, 29]
+        },
+        color: {
+          black: [30, 39],
+          red: [31, 39],
+          green: [32, 39],
+          yellow: [33, 39],
+          blue: [34, 39],
+          magenta: [35, 39],
+          cyan: [36, 39],
+          white: [37, 39],
+          gray: [90, 39],
+          // Bright color
+          redBright: [91, 39],
+          greenBright: [92, 39],
+          yellowBright: [93, 39],
+          blueBright: [94, 39],
+          magentaBright: [95, 39],
+          cyanBright: [96, 39],
+          whiteBright: [97, 39]
+        },
+        bgColor: {
+          bgBlack: [40, 49],
+          bgRed: [41, 49],
+          bgGreen: [42, 49],
+          bgYellow: [43, 49],
+          bgBlue: [44, 49],
+          bgMagenta: [45, 49],
+          bgCyan: [46, 49],
+          bgWhite: [47, 49],
+          // Bright color
+          bgBlackBright: [100, 49],
+          bgRedBright: [101, 49],
+          bgGreenBright: [102, 49],
+          bgYellowBright: [103, 49],
+          bgBlueBright: [104, 49],
+          bgMagentaBright: [105, 49],
+          bgCyanBright: [106, 49],
+          bgWhiteBright: [107, 49]
+        }
+      };
+      styles2.color.grey = styles2.color.gray;
+      for (const groupName of Object.keys(styles2)) {
+        const group = styles2[groupName];
+        for (const styleName of Object.keys(group)) {
+          const style = group[styleName];
+          styles2[styleName] = {
+            open: `\x1B[${style[0]}m`,
+            close: `\x1B[${style[1]}m`
+          };
+          group[styleName] = styles2[styleName];
+          codes.set(style[0], style[1]);
+        }
+        Object.defineProperty(styles2, groupName, {
+          value: group,
+          enumerable: false
+        });
+        Object.defineProperty(styles2, "codes", {
+          value: codes,
+          enumerable: false
+        });
+      }
+      const ansi2ansi = (n) => n;
+      const rgb2rgb = (r2, g2, b2) => [r2, g2, b2];
+      styles2.color.close = "\x1B[39m";
+      styles2.bgColor.close = "\x1B[49m";
+      styles2.color.ansi = {
+        ansi: wrapAnsi162(ansi2ansi, 0)
+      };
+      styles2.color.ansi256 = {
+        ansi256: wrapAnsi2562(ansi2ansi, 0)
+      };
+      styles2.color.ansi16m = {
+        rgb: wrapAnsi16m2(rgb2rgb, 0)
+      };
+      styles2.bgColor.ansi = {
+        ansi: wrapAnsi162(ansi2ansi, 10)
+      };
+      styles2.bgColor.ansi256 = {
+        ansi256: wrapAnsi2562(ansi2ansi, 10)
+      };
+      styles2.bgColor.ansi16m = {
+        rgb: wrapAnsi16m2(rgb2rgb, 10)
+      };
+      for (let key of Object.keys(colorConvert)) {
+        if (typeof colorConvert[key] !== "object") {
+          continue;
+        }
+        const suite = colorConvert[key];
+        if (key === "ansi16") {
+          key = "ansi";
+        }
+        if ("ansi16" in suite) {
+          styles2.color.ansi[key] = wrapAnsi162(suite.ansi16, 0);
+          styles2.bgColor.ansi[key] = wrapAnsi162(suite.ansi16, 10);
+        }
+        if ("ansi256" in suite) {
+          styles2.color.ansi256[key] = wrapAnsi2562(suite.ansi256, 0);
+          styles2.bgColor.ansi256[key] = wrapAnsi2562(suite.ansi256, 10);
+        }
+        if ("rgb" in suite) {
+          styles2.color.ansi16m[key] = wrapAnsi16m2(suite.rgb, 0);
+          styles2.bgColor.ansi16m[key] = wrapAnsi16m2(suite.rgb, 10);
+        }
+      }
+      return styles2;
+    }
+    Object.defineProperty(module2, "exports", {
+      enumerable: true,
+      get: assembleStyles2
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/has-flag@3.0.0/node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../node_modules/.pnpm/has-flag@3.0.0/node_modules/has-flag/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = (flag, argv) => {
+      argv = argv || process.argv;
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const pos = argv.indexOf(prefix + flag);
+      const terminatorPos = argv.indexOf("--");
+      return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "../../node_modules/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js"(exports2, module2) {
+    "use strict";
+    var os = require("os");
+    var hasFlag = require_has_flag();
+    var env2 = process.env;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false")) {
+      forceColor = false;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = true;
+    }
+    if ("FORCE_COLOR" in env2) {
+      forceColor = env2.FORCE_COLOR.length === 0 || parseInt(env2.FORCE_COLOR, 10) !== 0;
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(stream) {
+      if (forceColor === false) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (stream && !stream.isTTY && forceColor !== true) {
+        return 0;
+      }
+      const min = forceColor ? 1 : 0;
+      if (process.platform === "win32") {
+        const osRelease = os.release().split(".");
+        if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env2) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some((sign) => sign in env2) || env2.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env2) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env2.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env2.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env2) {
+        const version3 = parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env2.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version3 >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env2.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env2.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env2) {
+        return 1;
+      }
+      if (env2.TERM === "dumb") {
+        return min;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream);
+      return translateLevel(level);
+    }
+    module2.exports = {
+      supportsColor: getSupportLevel,
+      stdout: getSupportLevel(process.stdout),
+      stderr: getSupportLevel(process.stderr)
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/templates.js
+var require_templates = __commonJS({
+  "../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/templates.js"(exports2, module2) {
+    "use strict";
+    var TEMPLATE_REGEX = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+    var STYLE_REGEX = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+    var STRING_REGEX = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+    var ESCAPE_REGEX = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
+    var ESCAPES3 = /* @__PURE__ */ new Map([
+      ["n", "\n"],
+      ["r", "\r"],
+      ["t", "	"],
+      ["b", "\b"],
+      ["f", "\f"],
+      ["v", "\v"],
+      ["0", "\0"],
+      ["\\", "\\"],
+      ["e", "\x1B"],
+      ["a", "\x07"]
+    ]);
+    function unescape(c2) {
+      if (c2[0] === "u" && c2.length === 5 || c2[0] === "x" && c2.length === 3) {
+        return String.fromCharCode(parseInt(c2.slice(1), 16));
+      }
+      return ESCAPES3.get(c2) || c2;
+    }
+    function parseArguments(name2, args) {
+      const results = [];
+      const chunks = args.trim().split(/\s*,\s*/g);
+      let matches;
+      for (const chunk of chunks) {
+        if (!isNaN(chunk)) {
+          results.push(Number(chunk));
+        } else if (matches = chunk.match(STRING_REGEX)) {
+          results.push(matches[2].replace(ESCAPE_REGEX, (m2, escape, chr) => escape ? unescape(escape) : chr));
+        } else {
+          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name2}')`);
+        }
+      }
+      return results;
+    }
+    function parseStyle(style) {
+      STYLE_REGEX.lastIndex = 0;
+      const results = [];
+      let matches;
+      while ((matches = STYLE_REGEX.exec(style)) !== null) {
+        const name2 = matches[1];
+        if (matches[2]) {
+          const args = parseArguments(name2, matches[2]);
+          results.push([name2].concat(args));
+        } else {
+          results.push([name2]);
+        }
+      }
+      return results;
+    }
+    function buildStyle(chalk2, styles2) {
+      const enabled = {};
+      for (const layer of styles2) {
+        for (const style of layer.styles) {
+          enabled[style[0]] = layer.inverse ? null : style.slice(1);
+        }
+      }
+      let current = chalk2;
+      for (const styleName of Object.keys(enabled)) {
+        if (Array.isArray(enabled[styleName])) {
+          if (!(styleName in current)) {
+            throw new Error(`Unknown Chalk style: ${styleName}`);
+          }
+          if (enabled[styleName].length > 0) {
+            current = current[styleName].apply(current, enabled[styleName]);
+          } else {
+            current = current[styleName];
+          }
+        }
+      }
+      return current;
+    }
+    module2.exports = (chalk2, tmp) => {
+      const styles2 = [];
+      const chunks = [];
+      let chunk = [];
+      tmp.replace(TEMPLATE_REGEX, (m2, escapeChar, inverse, style, close, chr) => {
+        if (escapeChar) {
+          chunk.push(unescape(escapeChar));
+        } else if (style) {
+          const str = chunk.join("");
+          chunk = [];
+          chunks.push(styles2.length === 0 ? str : buildStyle(chalk2, styles2)(str));
+          styles2.push({ inverse, styles: parseStyle(style) });
+        } else if (close) {
+          if (styles2.length === 0) {
+            throw new Error("Found extraneous } in Chalk template literal");
+          }
+          chunks.push(buildStyle(chalk2, styles2)(chunk.join("")));
+          chunk = [];
+          styles2.pop();
+        } else {
+          chunk.push(chr);
+        }
+      });
+      chunks.push(chunk.join(""));
+      if (styles2.length > 0) {
+        const errMsg = `Chalk template literal is missing ${styles2.length} closing bracket${styles2.length === 1 ? "" : "s"} (\`}\`)`;
+        throw new Error(errMsg);
+      }
+      return chunks.join("");
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/index.js
+var require_chalk = __commonJS({
+  "../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/index.js"(exports2, module2) {
+    "use strict";
+    var escapeStringRegexp = require_escape_string_regexp();
+    var ansiStyles2 = require_ansi_styles();
+    var stdoutColor = require_supports_color().stdout;
+    var template = require_templates();
+    var isSimpleWindowsTerm = process.platform === "win32" && !(process.env.TERM || "").toLowerCase().startsWith("xterm");
+    var levelMapping = ["ansi", "ansi", "ansi256", "ansi16m"];
+    var skipModels = /* @__PURE__ */ new Set(["gray"]);
+    var styles2 = /* @__PURE__ */ Object.create(null);
+    function applyOptions(obj, options) {
+      options = options || {};
+      const scLevel = stdoutColor ? stdoutColor.level : 0;
+      obj.level = options.level === void 0 ? scLevel : options.level;
+      obj.enabled = "enabled" in options ? options.enabled : obj.level > 0;
+    }
+    function Chalk(options) {
+      if (!this || !(this instanceof Chalk) || this.template) {
+        const chalk2 = {};
+        applyOptions(chalk2, options);
+        chalk2.template = function() {
+          const args = [].slice.call(arguments);
+          return chalkTag.apply(null, [chalk2.template].concat(args));
+        };
+        Object.setPrototypeOf(chalk2, Chalk.prototype);
+        Object.setPrototypeOf(chalk2.template, chalk2);
+        chalk2.template.constructor = Chalk;
+        return chalk2.template;
+      }
+      applyOptions(this, options);
+    }
+    if (isSimpleWindowsTerm) {
+      ansiStyles2.blue.open = "\x1B[94m";
+    }
+    for (const key of Object.keys(ansiStyles2)) {
+      ansiStyles2[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles2[key].close), "g");
+      styles2[key] = {
+        get() {
+          const codes = ansiStyles2[key];
+          return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+        }
+      };
+    }
+    styles2.visible = {
+      get() {
+        return build.call(this, this._styles || [], true, "visible");
+      }
+    };
+    ansiStyles2.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles2.color.close), "g");
+    for (const model of Object.keys(ansiStyles2.color.ansi)) {
+      if (skipModels.has(model)) {
+        continue;
+      }
+      styles2[model] = {
+        get() {
+          const level = this.level;
+          return function() {
+            const open2 = ansiStyles2.color[levelMapping[level]][model].apply(null, arguments);
+            const codes = {
+              open: open2,
+              close: ansiStyles2.color.close,
+              closeRe: ansiStyles2.color.closeRe
+            };
+            return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+          };
+        }
+      };
+    }
+    ansiStyles2.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles2.bgColor.close), "g");
+    for (const model of Object.keys(ansiStyles2.bgColor.ansi)) {
+      if (skipModels.has(model)) {
+        continue;
+      }
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles2[bgModel] = {
+        get() {
+          const level = this.level;
+          return function() {
+            const open2 = ansiStyles2.bgColor[levelMapping[level]][model].apply(null, arguments);
+            const codes = {
+              open: open2,
+              close: ansiStyles2.bgColor.close,
+              closeRe: ansiStyles2.bgColor.closeRe
+            };
+            return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+          };
+        }
+      };
+    }
+    var proto = Object.defineProperties(() => {
+    }, styles2);
+    function build(_styles, _empty, key) {
+      const builder = function() {
+        return applyStyle.apply(builder, arguments);
+      };
+      builder._styles = _styles;
+      builder._empty = _empty;
+      const self = this;
+      Object.defineProperty(builder, "level", {
+        enumerable: true,
+        get() {
+          return self.level;
+        },
+        set(level) {
+          self.level = level;
+        }
+      });
+      Object.defineProperty(builder, "enabled", {
+        enumerable: true,
+        get() {
+          return self.enabled;
+        },
+        set(enabled) {
+          self.enabled = enabled;
+        }
+      });
+      builder.hasGrey = this.hasGrey || key === "gray" || key === "grey";
+      builder.__proto__ = proto;
+      return builder;
+    }
+    function applyStyle() {
+      const args = arguments;
+      const argsLen = args.length;
+      let str = String(arguments[0]);
+      if (argsLen === 0) {
+        return "";
+      }
+      if (argsLen > 1) {
+        for (let a = 1; a < argsLen; a++) {
+          str += " " + args[a];
+        }
+      }
+      if (!this.enabled || this.level <= 0 || !str) {
+        return this._empty ? "" : str;
+      }
+      const originalDim = ansiStyles2.dim.open;
+      if (isSimpleWindowsTerm && this.hasGrey) {
+        ansiStyles2.dim.open = "";
+      }
+      for (const code of this._styles.slice().reverse()) {
+        str = code.open + str.replace(code.closeRe, code.open) + code.close;
+        str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+      }
+      ansiStyles2.dim.open = originalDim;
+      return str;
+    }
+    function chalkTag(chalk2, strings) {
+      if (!Array.isArray(strings)) {
+        return [].slice.call(arguments, 1).join(" ");
+      }
+      const args = [].slice.call(arguments, 2);
+      const parts = [strings.raw[0]];
+      for (let i = 1; i < strings.length; i++) {
+        parts.push(String(args[i - 1]).replace(/[{}\\]/g, "\\$&"));
+        parts.push(String(strings.raw[i]));
+      }
+      return template(chalk2, parts.join(""));
+    }
+    Object.defineProperties(Chalk.prototype, styles2);
+    module2.exports = Chalk();
+    module2.exports.supportsColor = stdoutColor;
+    module2.exports.default = module2.exports;
+  }
+});
+
 // ../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
 var require_src = __commonJS({
   "../../node_modules/.pnpm/sisteransi@1.0.5/node_modules/sisteransi/src/index.js"(exports2, module2) {
     "use strict";
-    var ESC3 = "\x1B";
-    var CSI = `${ESC3}[`;
+    var ESC2 = "\x1B";
+    var CSI = `${ESC2}[`;
     var beep = "\x07";
     var cursor = {
       to(x2, y2) {
@@ -67,8 +1610,8 @@ var require_src = __commonJS({
       left: `${CSI}G`,
       hide: `${CSI}?25l`,
       show: `${CSI}?25h`,
-      save: `${ESC3}7`,
-      restore: `${ESC3}8`
+      save: `${ESC2}7`,
+      restore: `${ESC2}8`
     };
     var scroll = {
       up: (count = 1) => `${CSI}S`.repeat(count),
@@ -97,8 +1640,8 @@ var require_src = __commonJS({
 // ../../node_modules/.pnpm/picocolors@1.0.0/node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS({
   "../../node_modules/.pnpm/picocolors@1.0.0/node_modules/picocolors/picocolors.js"(exports2, module2) {
-    var tty2 = require("tty");
-    var isColorSupported = !("NO_COLOR" in process.env || process.argv.includes("--no-color")) && ("FORCE_COLOR" in process.env || process.argv.includes("--color") || process.platform === "win32" || tty2.isatty(1) && process.env.TERM !== "dumb" || "CI" in process.env);
+    var tty = require("tty");
+    var isColorSupported = !("NO_COLOR" in process.env || process.argv.includes("--no-color")) && ("FORCE_COLOR" in process.env || process.argv.includes("--color") || process.platform === "win32" || tty.isatty(1) && process.env.TERM !== "dumb" || "CI" in process.env);
     var formatter = (open2, close, replace = open2) => (input) => {
       let string = "" + input;
       let index = string.indexOf(close, open2.length);
@@ -236,11 +1779,11 @@ var require_signals = __commonJS({
 // ../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js
 var require_signal_exit = __commonJS({
   "../../node_modules/.pnpm/signal-exit@3.0.7/node_modules/signal-exit/index.js"(exports2, module2) {
-    var process7 = global.process;
-    var processOk = function(process8) {
-      return process8 && typeof process8 === "object" && typeof process8.removeListener === "function" && typeof process8.emit === "function" && typeof process8.reallyExit === "function" && typeof process8.listeners === "function" && typeof process8.kill === "function" && typeof process8.pid === "number" && typeof process8.on === "function";
+    var process5 = global.process;
+    var processOk = function(process6) {
+      return process6 && typeof process6 === "object" && typeof process6.removeListener === "function" && typeof process6.emit === "function" && typeof process6.reallyExit === "function" && typeof process6.listeners === "function" && typeof process6.kill === "function" && typeof process6.pid === "number" && typeof process6.on === "function";
     };
-    if (!processOk(process7)) {
+    if (!processOk(process5)) {
       module2.exports = function() {
         return function() {
         };
@@ -248,15 +1791,15 @@ var require_signal_exit = __commonJS({
     } else {
       assert = require("assert");
       signals = require_signals();
-      isWin = /^win/i.test(process7.platform);
+      isWin = /^win/i.test(process5.platform);
       EE = require("events");
       if (typeof EE !== "function") {
         EE = EE.EventEmitter;
       }
-      if (process7.__signal_exit_emitter__) {
-        emitter = process7.__signal_exit_emitter__;
+      if (process5.__signal_exit_emitter__) {
+        emitter = process5.__signal_exit_emitter__;
       } else {
-        emitter = process7.__signal_exit_emitter__ = new EE();
+        emitter = process5.__signal_exit_emitter__ = new EE();
         emitter.count = 0;
         emitter.emitted = {};
       }
@@ -293,12 +1836,12 @@ var require_signal_exit = __commonJS({
         loaded = false;
         signals.forEach(function(sig) {
           try {
-            process7.removeListener(sig, sigListeners[sig]);
+            process5.removeListener(sig, sigListeners[sig]);
           } catch (er) {
           }
         });
-        process7.emit = originalProcessEmit;
-        process7.reallyExit = originalProcessReallyExit;
+        process5.emit = originalProcessEmit;
+        process5.reallyExit = originalProcessReallyExit;
         emitter.count -= 1;
       };
       module2.exports.unload = unload;
@@ -315,7 +1858,7 @@ var require_signal_exit = __commonJS({
           if (!processOk(global.process)) {
             return;
           }
-          var listeners = process7.listeners(sig);
+          var listeners = process5.listeners(sig);
           if (listeners.length === emitter.count) {
             unload();
             emit("exit", null, sig);
@@ -323,7 +1866,7 @@ var require_signal_exit = __commonJS({
             if (isWin && sig === "SIGHUP") {
               sig = "SIGINT";
             }
-            process7.kill(process7.pid, sig);
+            process5.kill(process5.pid, sig);
           }
         };
       });
@@ -339,36 +1882,36 @@ var require_signal_exit = __commonJS({
         emitter.count += 1;
         signals = signals.filter(function(sig) {
           try {
-            process7.on(sig, sigListeners[sig]);
+            process5.on(sig, sigListeners[sig]);
             return true;
           } catch (er) {
             return false;
           }
         });
-        process7.emit = processEmit;
-        process7.reallyExit = processReallyExit;
+        process5.emit = processEmit;
+        process5.reallyExit = processReallyExit;
       };
       module2.exports.load = load;
-      originalProcessReallyExit = process7.reallyExit;
+      originalProcessReallyExit = process5.reallyExit;
       processReallyExit = function processReallyExit2(code) {
         if (!processOk(global.process)) {
           return;
         }
-        process7.exitCode = code || /* istanbul ignore next */
+        process5.exitCode = code || /* istanbul ignore next */
         0;
-        emit("exit", process7.exitCode, null);
-        emit("afterexit", process7.exitCode, null);
-        originalProcessReallyExit.call(process7, process7.exitCode);
+        emit("exit", process5.exitCode, null);
+        emit("afterexit", process5.exitCode, null);
+        originalProcessReallyExit.call(process5, process5.exitCode);
       };
-      originalProcessEmit = process7.emit;
+      originalProcessEmit = process5.emit;
       processEmit = function processEmit2(ev, arg) {
         if (ev === "exit" && processOk(global.process)) {
           if (arg !== void 0) {
-            process7.exitCode = arg;
+            process5.exitCode = arg;
           }
           var ret = originalProcessEmit.apply(this, arguments);
-          emit("exit", process7.exitCode, null);
-          emit("afterexit", process7.exitCode, null);
+          emit("exit", process5.exitCode, null);
+          emit("afterexit", process5.exitCode, null);
           return ret;
         } else {
           return originalProcessEmit.apply(this, arguments);
@@ -618,22 +2161,22 @@ var require_isexe = __commonJS({
 // ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
 var require_which = __commonJS({
   "../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports2, module2) {
-    var isWindows2 = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
     var path3 = require("path");
-    var COLON = isWindows2 ? ";" : ":";
+    var COLON = isWindows ? ";" : ":";
     var isexe = require_isexe();
     var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
     var getPathInfo = (cmd, opt) => {
       const colon = opt.colon || COLON;
-      const pathEnv = cmd.match(/\//) || isWindows2 && cmd.match(/\\/) ? [""] : [
+      const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
         // windows always checks the cwd first
-        ...isWindows2 ? [process.cwd()] : [],
+        ...isWindows ? [process.cwd()] : [],
         ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
         "").split(colon)
       ];
-      const pathExtExe = isWindows2 ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
-      const pathExt = isWindows2 ? pathExtExe.split(colon) : [""];
-      if (isWindows2) {
+      const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+      const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+      if (isWindows) {
         if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
           pathExt.unshift("");
       }
@@ -736,7 +2279,7 @@ var require_resolveCommand = __commonJS({
     var which = require_which();
     var getPathKey = require_path_key();
     function resolveCommandAttempt(parsed, withoutPathExt) {
-      const env3 = parsed.options.env || process.env;
+      const env2 = parsed.options.env || process.env;
       const cwd = process.cwd();
       const hasCustomCwd = parsed.options.cwd != null;
       const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
@@ -749,7 +2292,7 @@ var require_resolveCommand = __commonJS({
       let resolved;
       try {
         resolved = which.sync(parsed.command, {
-          path: env3[getPathKey({ env: env3 })],
+          path: env2[getPathKey({ env: env2 })],
           pathExt: withoutPathExt ? path3.delimiter : void 0
         });
       } catch (e) {
@@ -5931,7 +7474,7 @@ var require_util2 = __commonJS({
     }
     function fullyReadBody(body, processBody, processBodyError) {
       const successSteps = (bytes) => queueMicrotask(() => processBody(bytes));
-      const errorSteps = (error) => queueMicrotask(() => processBodyError(error));
+      const errorSteps = (error2) => queueMicrotask(() => processBodyError(error2));
       let reader;
       try {
         reader = body.stream.getReader();
@@ -7335,7 +8878,7 @@ Content-Type: ${value.type || "application/octet-stream"}\r
         throw new TypeError("Body is unusable");
       }
       const promise = createDeferredPromise();
-      const errorSteps = (error) => promise.reject(error);
+      const errorSteps = (error2) => promise.reject(error2);
       const successSteps = (data) => {
         try {
           promise.resolve(convertBytesToJSValue(data));
@@ -7572,15 +9115,15 @@ var require_request = __commonJS({
         }
         return this[kHandler].onComplete(trailers);
       }
-      onError(error) {
+      onError(error2) {
         if (channels.error.hasSubscribers) {
-          channels.error.publish({ request: this, error });
+          channels.error.publish({ request: this, error: error2 });
         }
         if (this.aborted) {
           return;
         }
         this.aborted = true;
-        return this[kHandler].onError(error);
+        return this[kHandler].onError(error2);
       }
       addHeader(key, value) {
         processHeader(this, key, value);
@@ -8384,8 +9927,8 @@ var require_RedirectHandler = __commonJS({
       onUpgrade(statusCode, headers, socket) {
         this.handler.onUpgrade(statusCode, headers, socket);
       }
-      onError(error) {
-        this.handler.onError(error);
+      onError(error2) {
+        this.handler.onError(error2);
       }
       onHeaders(statusCode, headers, resume, statusText) {
         this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
@@ -11666,13 +13209,13 @@ var require_mock_utils = __commonJS({
       if (mockDispatch2.data.callback) {
         mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) };
       }
-      const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch2;
+      const { data: { statusCode, data, headers, trailers, error: error2 }, delay, persist } = mockDispatch2;
       const { timesInvoked, times } = mockDispatch2;
       mockDispatch2.consumed = !persist && timesInvoked >= times;
       mockDispatch2.pending = timesInvoked < times;
-      if (error !== null) {
+      if (error2 !== null) {
         deleteMockDispatch(this[kDispatches], key);
-        handler.onError(error);
+        handler.onError(error2);
         return true;
       }
       if (typeof delay === "number" && delay > 0) {
@@ -11710,19 +13253,19 @@ var require_mock_utils = __commonJS({
         if (agent.isMockActive) {
           try {
             mockDispatch.call(this, opts, handler);
-          } catch (error) {
-            if (error instanceof MockNotMatchedError) {
+          } catch (error2) {
+            if (error2 instanceof MockNotMatchedError) {
               const netConnect = agent[kGetNetConnect]();
               if (netConnect === false) {
-                throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`);
+                throw new MockNotMatchedError(`${error2.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`);
               }
               if (checkNetConnect(netConnect, origin)) {
                 originalDispatch.call(this, opts, handler);
               } else {
-                throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`);
+                throw new MockNotMatchedError(`${error2.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`);
               }
             } else {
-              throw error;
+              throw error2;
             }
           }
         } else {
@@ -11885,11 +13428,11 @@ var require_mock_interceptor = __commonJS({
       /**
        * Mock an undici request with a defined error.
        */
-      replyWithError(error) {
-        if (typeof error === "undefined") {
+      replyWithError(error2) {
+        if (typeof error2 === "undefined") {
           throw new InvalidArgumentError("error must be defined");
         }
-        const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error });
+        const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error: error2 });
         return new MockScope(newMockDispatch);
       }
       /**
@@ -13914,17 +15457,17 @@ var require_fetch = __commonJS({
         this.emit("terminated", reason);
       }
       // https://fetch.spec.whatwg.org/#fetch-controller-abort
-      abort(error) {
+      abort(error2) {
         if (this.state !== "ongoing") {
           return;
         }
         this.state = "aborted";
-        if (!error) {
-          error = new DOMException("The operation was aborted.", "AbortError");
+        if (!error2) {
+          error2 = new DOMException("The operation was aborted.", "AbortError");
         }
-        this.serializedAbortReason = error;
-        this.connection?.destroy(error);
-        this.emit("terminated", error);
+        this.serializedAbortReason = error2;
+        this.connection?.destroy(error2);
+        this.emit("terminated", error2);
       }
     };
     async function fetch2(input, init = {}) {
@@ -14030,13 +15573,13 @@ var require_fetch = __commonJS({
         performance.markResourceTiming(timingInfo, originalURL, initiatorType, globalThis2, cacheState);
       }
     }
-    function abortFetch(p2, request2, responseObject, error) {
-      if (!error) {
-        error = new DOMException("The operation was aborted.", "AbortError");
+    function abortFetch(p2, request2, responseObject, error2) {
+      if (!error2) {
+        error2 = new DOMException("The operation was aborted.", "AbortError");
       }
-      p2.reject(error);
+      p2.reject(error2);
       if (request2.body != null && isReadable(request2.body?.stream)) {
-        request2.body.stream.cancel(error).catch((err) => {
+        request2.body.stream.cancel(error2).catch((err) => {
           if (err.code === "ERR_INVALID_STATE") {
             return;
           }
@@ -14048,7 +15591,7 @@ var require_fetch = __commonJS({
       }
       const response = responseObject[kState];
       if (response.body != null && isReadable(response.body?.stream)) {
-        response.body.stream.cancel(error).catch((err) => {
+        response.body.stream.cancel(error2).catch((err) => {
           if (err.code === "ERR_INVALID_STATE") {
             return;
           }
@@ -14801,13 +16344,13 @@ var require_fetch = __commonJS({
               fetchParams.controller.ended = true;
               this.body.push(null);
             },
-            onError(error) {
+            onError(error2) {
               if (this.abort) {
                 fetchParams.controller.off("terminated", this.abort);
               }
-              this.body?.destroy(error);
-              fetchParams.controller.terminate(error);
-              reject(error);
+              this.body?.destroy(error2);
+              fetchParams.controller.terminate(error2);
+              reject(error2);
             },
             onUpgrade(status2, headersList, socket) {
               if (status2 !== 101) {
@@ -15270,8 +16813,8 @@ var require_util3 = __commonJS({
                   }
                   fr[kResult] = result;
                   fireAProgressEvent("load", fr);
-                } catch (error) {
-                  fr[kError] = error;
+                } catch (error2) {
+                  fr[kError] = error2;
                   fireAProgressEvent("error", fr);
                 }
                 if (fr[kState] !== "loading") {
@@ -15280,13 +16823,13 @@ var require_util3 = __commonJS({
               });
               break;
             }
-          } catch (error) {
+          } catch (error2) {
             if (fr[kAborted]) {
               return;
             }
             queueMicrotask(() => {
               fr[kState] = "done";
-              fr[kError] = error;
+              fr[kError] = error2;
               fireAProgressEvent("error", fr);
               if (fr[kState] !== "loading") {
                 fireAProgressEvent("loadend", fr);
@@ -16926,11 +18469,11 @@ var require_connection = __commonJS({
         });
       }
     }
-    function onSocketError(error) {
+    function onSocketError(error2) {
       const { ws } = this;
       ws[kReadyState] = states.CLOSING;
       if (channels.socketError.hasSubscribers) {
-        channels.socketError.publish(error);
+        channels.socketError.publish(error2);
       }
       this.destroy();
     }
@@ -17717,8 +19260,8 @@ var require_lodash = __commonJS({
       return false;
     }
     function isPrototype(value) {
-      var Ctor = value && value.constructor, proto2 = typeof Ctor == "function" && Ctor.prototype || objectProto;
-      return value === proto2;
+      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto;
+      return value === proto;
     }
     function nativeKeysIn(object) {
       var result = [];
@@ -17899,14 +19442,14 @@ var require_is_docker = __commonJS({
 var require_is_wsl = __commonJS({
   "../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js"(exports2, module2) {
     "use strict";
-    var os2 = require("os");
+    var os = require("os");
     var fs2 = require("fs");
     var isDocker = require_is_docker();
     var isWsl = () => {
       if (process.platform !== "linux") {
         return false;
       }
-      if (os2.release().toLowerCase().includes("microsoft")) {
+      if (os.release().toLowerCase().includes("microsoft")) {
         if (isDocker()) {
           return false;
         }
@@ -17992,8 +19535,8 @@ var require_open = __commonJS({
       for (const item of array) {
         try {
           return await mapper(item);
-        } catch (error) {
-          latestError = error;
+        } catch (error2) {
+          latestError = error2;
         }
       }
       throw latestError;
@@ -21494,7 +23037,7 @@ var require_doh = __commonJS({
       constructor(options) {
         super();
         const { ssl } = Object.assign(this, { cors: true }, options);
-        this.server = (ssl ? https.createServer(options) : http.createServer()).on("request", this.handleRequest.bind(this)).on("listening", () => this.emit("listening", this.address())).on("error", (error) => this.emit("error", error)).on("close", () => {
+        this.server = (ssl ? https.createServer(options) : http.createServer()).on("request", this.handleRequest.bind(this)).on("listening", () => this.emit("listening", this.address())).on("error", (error2) => this.emit("error", error2)).on("close", () => {
           this.server.removeAllListeners();
           this.emit("close");
         });
@@ -21604,13 +23147,13 @@ var require_dns = __commonJS({
         super();
         this.servers = {};
         if (options.doh) {
-          this.servers.doh = new DOHServer(options.doh).on("error", (error) => this.emit("error", error, "doh"));
+          this.servers.doh = new DOHServer(options.doh).on("error", (error2) => this.emit("error", error2, "doh"));
         }
         if (options.tcp) {
-          this.servers.tcp = new TCPServer().on("error", (error) => this.emit("error", error, "tcp"));
+          this.servers.tcp = new TCPServer().on("error", (error2) => this.emit("error", error2, "tcp"));
         }
         if (options.udp) {
-          this.servers.udp = new UDPServer(typeof options.udp === "object" ? options.udp : void 0).on("error", (error) => this.emit("error", error, "udp"));
+          this.servers.udp = new UDPServer(typeof options.udp === "object" ? options.udp : void 0).on("error", (error2) => this.emit("error", error2, "udp"));
         }
         const servers = Object.values(this.servers);
         this.closed = Promise.all(
@@ -21626,7 +23169,7 @@ var require_dns = __commonJS({
           return addresses;
         });
         const emitRequest = (request2, send, client) => this.emit("request", request2, send, client);
-        const emitRequestError = (error) => this.emit("requestError", error);
+        const emitRequestError = (error2) => this.emit("requestError", error2);
         for (const server of servers) {
           server.on("request", emitRequest);
           server.on("requestError", emitRequestError);
@@ -22011,8 +23554,8 @@ var require_parse4 = __commonJS({
       r2.lastIndex = origIndex;
       return matches;
     }
-    function getVar(env3, pre, key) {
-      var r2 = typeof env3 === "function" ? env3(key) : env3[key];
+    function getVar(env2, pre, key) {
+      var r2 = typeof env2 === "function" ? env2(key) : env2[key];
       if (typeof r2 === "undefined" && key != "") {
         r2 = "";
       } else if (typeof r2 === "undefined") {
@@ -22023,7 +23566,7 @@ var require_parse4 = __commonJS({
       }
       return pre + r2;
     }
-    function parseInternal(string, env3, opts) {
+    function parseInternal(string, env2, opts) {
       if (!opts) {
         opts = {};
       }
@@ -22038,8 +23581,8 @@ var require_parse4 = __commonJS({
       if (matches.length === 0) {
         return [];
       }
-      if (!env3) {
-        env3 = {};
+      if (!env2) {
+        env2 = {};
       }
       var commented = false;
       return matches.map(function(match) {
@@ -22085,7 +23628,7 @@ var require_parse4 = __commonJS({
               i2 += varend.index - 1;
             }
           }
-          return getVar(env3, "", varname);
+          return getVar(env2, "", varname);
         }
         for (i2 = 0; i2 < s.length; i2++) {
           var c2 = s.charAt(i2);
@@ -22140,9 +23683,9 @@ var require_parse4 = __commonJS({
         return typeof arg === "undefined" ? prev : prev.concat(arg);
       }, []);
     }
-    module2.exports = function parse2(s, env3, opts) {
-      var mapped = parseInternal(s, env3, opts);
-      if (typeof env3 !== "function") {
+    module2.exports = function parse2(s, env2, opts) {
+      var mapped = parseInternal(s, env2, opts);
+      if (typeof env2 !== "function") {
         return mapped;
       }
       return mapped.reduce(function(acc, s2) {
@@ -23910,12 +25453,12 @@ var require_parse_stream = __commonJS({
             reject(err);
           }
         }
-        function error(err) {
+        function error2(err) {
           errored = true;
           reject(err);
         }
         stm.once("end", finish);
-        stm.once("error", error);
+        stm.once("error", error2);
         readNext();
         function readNext() {
           readable = true;
@@ -23924,7 +25467,7 @@ var require_parse_stream = __commonJS({
             try {
               parser2.parse(data);
             } catch (err) {
-              return error(err);
+              return error2(err);
             }
           }
           readable = false;
@@ -24492,8 +26035,8 @@ function __read(o, n) {
   try {
     while ((n === void 0 || n-- > 0) && !(r2 = i.next()).done)
       ar.push(r2.value);
-  } catch (error) {
-    e = { error };
+  } catch (error2) {
+    e = { error: error2 };
   } finally {
     try {
       if (r2 && !r2.done && (m2 = i["return"]))
@@ -29830,13 +31373,13 @@ var require_util7 = __commonJS({
     var SourceMapGenerator = source_map_1.default.SourceMapGenerator;
     var hasOwn = Object.prototype.hasOwnProperty;
     function getLineTerminator() {
-      return isBrowser2() ? "\n" : require("os").EOL || "\n";
+      return isBrowser() ? "\n" : require("os").EOL || "\n";
     }
     exports2.getLineTerminator = getLineTerminator;
-    function isBrowser2() {
+    function isBrowser() {
       return typeof window !== "undefined" && typeof window.document !== "undefined";
     }
-    exports2.isBrowser = isBrowser2;
+    exports2.isBrowser = isBrowser;
     function getOption(options, key, defaultValue) {
       if (options && hasOwn.call(options, key)) {
         return options[key];
@@ -34685,45 +36228,45 @@ var require_esprima2 = __commonJS({
                 this.errors = [];
                 this.tolerant = false;
               }
-              ErrorHandler2.prototype.recordError = function(error) {
-                this.errors.push(error);
+              ErrorHandler2.prototype.recordError = function(error2) {
+                this.errors.push(error2);
               };
-              ErrorHandler2.prototype.tolerate = function(error) {
+              ErrorHandler2.prototype.tolerate = function(error2) {
                 if (this.tolerant) {
-                  this.recordError(error);
+                  this.recordError(error2);
                 } else {
-                  throw error;
+                  throw error2;
                 }
               };
               ErrorHandler2.prototype.constructError = function(msg, column) {
-                var error = new Error(msg);
+                var error2 = new Error(msg);
                 try {
-                  throw error;
+                  throw error2;
                 } catch (base) {
                   if (Object.create && Object.defineProperty) {
-                    error = Object.create(base);
-                    Object.defineProperty(error, "column", { value: column });
+                    error2 = Object.create(base);
+                    Object.defineProperty(error2, "column", { value: column });
                   }
                 }
-                return error;
+                return error2;
               };
               ErrorHandler2.prototype.createError = function(index, line, col, description) {
                 var msg = "Line " + line + ": " + description;
-                var error = this.constructError(msg, col);
-                error.index = index;
-                error.lineNumber = line;
-                error.description = description;
-                return error;
+                var error2 = this.constructError(msg, col);
+                error2.index = index;
+                error2.lineNumber = line;
+                error2.description = description;
+                return error2;
               };
               ErrorHandler2.prototype.throwError = function(index, line, col, description) {
                 throw this.createError(index, line, col, description);
               };
               ErrorHandler2.prototype.tolerateError = function(index, line, col, description) {
-                var error = this.createError(index, line, col, description);
+                var error2 = this.createError(index, line, col, description);
                 if (this.tolerant) {
-                  this.recordError(error);
+                  this.recordError(error2);
                 } else {
-                  throw error;
+                  throw error2;
                 }
               };
               return ErrorHandler2;
@@ -43943,15 +45486,15 @@ var require_lib2 = __commonJS({
           at
         } = raiseProperties, details = _objectWithoutPropertiesLoose(raiseProperties, _excluded);
         const loc = at instanceof Position ? at : at.loc.start;
-        const error = toParseError({
+        const error2 = toParseError({
           loc,
           details
         });
         if (!this.options.errorRecovery)
-          throw error;
+          throw error2;
         if (!this.isLookahead)
-          this.state.errors.push(error);
-        return error;
+          this.state.errors.push(error2);
+        return error2;
       }
       raiseOverwrite(toParseError, raiseProperties) {
         const {
@@ -43961,14 +45504,14 @@ var require_lib2 = __commonJS({
         const pos = loc.index;
         const errors = this.state.errors;
         for (let i = errors.length - 1; i >= 0; i--) {
-          const error = errors[i];
-          if (error.loc.index === pos) {
+          const error2 = errors[i];
+          if (error2.loc.index === pos) {
             return errors[i] = toParseError({
               loc,
               details
             });
           }
-          if (error.loc.index < pos)
+          if (error2.loc.index < pos)
             break;
         }
         return this.raise(toParseError, raiseProperties);
@@ -43998,9 +45541,9 @@ var require_lib2 = __commonJS({
           });
         }
       }
-      errorBuilder(error) {
+      errorBuilder(error2) {
         return (pos, lineStart, curLine) => {
-          this.raise(error, {
+          this.raise(error2, {
             at: buildPosition(pos, lineStart, curLine)
           });
         };
@@ -44155,7 +45698,7 @@ var require_lib2 = __commonJS({
         }
         this.parser.raise(toParseError, origin);
       }
-      recordArrowParameterBindingError(error, {
+      recordArrowParameterBindingError(error2, {
         at: node
       }) {
         const {
@@ -44166,9 +45709,9 @@ var require_lib2 = __commonJS({
           at: node.loc.start
         };
         if (scope.isCertainlyParameterDeclaration()) {
-          this.parser.raise(error, origin);
+          this.parser.raise(error2, origin);
         } else if (scope.canBeArrowParameterDeclaration()) {
-          scope.recordDeclarationError(error, origin);
+          scope.recordDeclarationError(error2, origin);
         } else {
           return;
         }
@@ -44353,19 +45896,19 @@ var require_lib2 = __commonJS({
             aborted: false,
             failState: null
           };
-        } catch (error) {
+        } catch (error2) {
           const failState = this.state;
           this.state = oldState;
-          if (error instanceof SyntaxError) {
+          if (error2 instanceof SyntaxError) {
             return {
               node: null,
-              error,
+              error: error2,
               thrown: true,
               aborted: false,
               failState
             };
           }
-          if (error === abortSignal) {
+          if (error2 === abortSignal) {
             return {
               node: abortSignal.node,
               error: null,
@@ -44374,7 +45917,7 @@ var require_lib2 = __commonJS({
               failState
             };
           }
-          throw error;
+          throw error2;
         }
       }
       checkExpressionErrors(refExpressionErrors, andThrow) {
@@ -51271,9 +52814,9 @@ var require_lib2 = __commonJS({
         throw new Error("The 'syntaxType' option of the 'recordAndTuple' plugin must be one of: " + RECORD_AND_TUPLE_SYNTAX_TYPES.map((p2) => `'${p2}'`).join(", "));
       }
       if (hasPlugin(plugins, "asyncDoExpressions") && !hasPlugin(plugins, "doExpressions")) {
-        const error = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
-        error.missingPlugins = "doExpressions";
-        throw error;
+        const error2 = new Error("'asyncDoExpressions' requires 'doExpressions', please add 'doExpressions' to parser plugins.");
+        error2.missingPlugins = "doExpressions";
+        throw error2;
       }
     }
     var mixinPlugins = {
@@ -55293,506 +56836,18 @@ module.exports = __toCommonJS(cli_exports);
 // ../cli/index.ts
 var import_process = require("process");
 
-// ../../node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red2, green2, blue2) => `\x1B[${38 + offset};2;${red2};${green2};${blue2}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    // 21 isn't widely supported and 22 does the same thing
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    // Bright color
-    blackBright: [90, 39],
-    gray: [90, 39],
-    // Alias of `blackBright`
-    grey: [90, 39],
-    // Alias of `blackBright`
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    // Bright color
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    // Alias of `bgBlackBright`
-    bgGrey: [100, 49],
-    // Alias of `bgBlackBright`
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = /* @__PURE__ */ new Map();
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
-    }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
-    });
-  }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red2, green2, blue2) {
-        if (red2 === green2 && green2 === blue2) {
-          if (red2 < 8) {
-            return 16;
-          }
-          if (red2 > 248) {
-            return 231;
-          }
-          return Math.round((red2 - 8) / 247 * 24) + 232;
-        }
-        return 16 + 36 * Math.round(red2 / 255 * 5) + 6 * Math.round(green2 / 255 * 5) + Math.round(blue2 / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
-        }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
-        }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          /* eslint-disable no-bitwise */
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-          /* eslint-enable no-bitwise */
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code) {
-        if (code < 8) {
-          return 30 + code;
-        }
-        if (code < 16) {
-          return 90 + (code - 8);
-        }
-        let red2;
-        let green2;
-        let blue2;
-        if (code >= 232) {
-          red2 = ((code - 232) * 10 + 8) / 255;
-          green2 = red2;
-          blue2 = red2;
-        } else {
-          code -= 16;
-          const remainder = code % 36;
-          red2 = Math.floor(code / 36) / 5;
-          green2 = Math.floor(remainder / 6) / 5;
-          blue2 = remainder % 6 / 5;
-        }
-        const value = Math.max(red2, green2, blue2) * 2;
-        if (value === 0) {
-          return 30;
-        }
-        let result = 30 + (Math.round(blue2) << 2 | Math.round(green2) << 1 | Math.round(red2));
-        if (value === 2) {
-          result += 60;
-        }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red2, green2, blue2) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red2, green2, blue2)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
-    }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// ../../node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/vendor/supports-color/index.js
-var import_node_process = __toESM(require("node:process"), 1);
-var import_node_os = __toESM(require("node:os"), 1);
-var import_node_tty = __toESM(require("node:tty"), 1);
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env } = import_node_process.default;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== void 0) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
-    }
-  }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === void 0) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (import_node_process.default.platform === "win32") {
-    const osRelease = import_node_os.default.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
-    }
-    return 1;
-  }
-  if ("CI" in env) {
-    if ("GITHUB_ACTIONS" in env) {
-      return 3;
-    }
-    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
-      return 1;
-    }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if ("TERM_PROGRAM" in env) {
-    const version3 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version3 >= 3 ? 3 : 2;
-      }
-      case "Apple_Terminal": {
-        return 2;
-      }
-    }
-  }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env) {
-    return 1;
-  }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
-}
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
-};
-var supports_color_default = supportsColor;
-
-// ../../node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
-    endIndex = index + 1;
-    index = string.indexOf("\n", endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-
-// ../../node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = /* @__PURE__ */ Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === void 0 ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk2 = (...strings) => strings.join(" ");
-  applyOptions(chalk2, options);
-  Object.setPrototypeOf(chalk2, createChalk.prototype);
-  return chalk2;
-};
-function createChalk(options) {
-  return chalkFactory(options);
-}
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-}
-var proto = Object.defineProperties(() => {
-}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
-    }
-  }
-});
-var createStyler = (open2, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === void 0) {
-    openAll = open2;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open2;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open: open2,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
-  }
-  let styler = self[STYLER];
-  if (styler === void 0) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== void 0) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
-    }
-  }
-  const lfIndex = string.indexOf("\n");
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
 // ../cli/colors.ts
-var { white, gray, dim, hidden, bold } = source_default;
-var brandColor = source_default.hex("#BD5B08");
-var black = source_default.hex("#111");
-var blue = source_default.hex("#0E838F");
+var import_chalk = __toESM(require_chalk());
+var { white, gray, dim, hidden, bold, cyanBright, bgCyan } = import_chalk.default;
+var brandColor = import_chalk.default.hex("#BD5B08");
+var black = import_chalk.default.hex("#111");
+var blue = import_chalk.default.hex("#0E838F");
 var bgBlue = black.bgHex("#0E838F");
-var red = source_default.hex("#AB2526");
+var red = import_chalk.default.hex("#AB2526");
 var bgRed = black.bgHex("#AB2526");
-var green = source_default.hex("#218529");
+var green = import_chalk.default.hex("#218529");
 var bgGreen = black.bgHex("#218529");
-var yellow = source_default.hex("#7F7322");
+var yellow = import_chalk.default.hex("#7F7322");
 var bgYellow = black.bgHex("#7F7322");
 
 // ../cli/index.ts
@@ -55835,15 +56890,22 @@ var log = (msg) => {
 var newline = () => {
   log("");
 };
-var updateStatus = (msg) => {
-  logRaw(`${gray(shapes.leftT)} ${msg}`);
-  newline();
+var updateStatus = (msg, printNewLine = true) => {
+  const lines = msg.split("\n");
+  const restLines = lines.slice(1).map((ln) => `${gray(shapes.bar)} ${white(ln)}`);
+  logRaw(`${gray(shapes.leftT)} ${lines[0]}`);
+  if (restLines.length) {
+    logRaw(restLines.join("\n"));
+  }
+  if (printNewLine)
+    newline();
 };
-var startSection = (heading, subheading) => {
+var startSection = (heading, subheading, printNewLine = true) => {
   logRaw(
     `${gray(shapes.corners.tl)} ${brandColor(heading)} ${subheading ? dim(subheading) : ""}`
   );
-  newline();
+  if (printNewLine)
+    newline();
 };
 var endSection = (heading, subheading) => {
   logRaw(
@@ -55867,19 +56929,24 @@ var stripAnsi = (str) => {
   const regex2 = RegExp(pattern, "g");
   return str.replace(regex2, "");
 };
-var crash = (msg) => {
+var crash = (msg, extra) => {
+  error(msg, extra);
+  (0, import_process.exit)(1);
+};
+var error = (msg, extra) => {
   if (msg) {
-    process.stderr.write(red(msg));
-    process.stderr.write("\n");
+    process.stderr.write(
+      `${gray(shapes.corners.bl)} ${status.error} ${dim(msg)}
+${extra ? space() + extra + "\n" : ""}`
+    );
   }
-  (0, import_process.exit)(1);
 };
 
 // ../../node_modules/.pnpm/@clack+core@0.3.2/node_modules/@clack/core/dist/index.mjs
 var import_sisteransi = __toESM(require_src(), 1);
-var import_node_process2 = require("node:process");
+var import_node_process = require("node:process");
 var import_node_readline = __toESM(require("node:readline"), 1);
-var import_node_tty2 = require("node:tty");
+var import_node_tty = require("node:tty");
 var import_picocolors = __toESM(require_picocolors(), 1);
 function z({ onlyFirst: t = false } = {}) {
   const u = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))"].join("|");
@@ -56092,17 +57159,20 @@ function FD(t, u) {
   return s;
 }
 var R = Symbol("clack:cancel");
+function eD(t) {
+  return t === R;
+}
 function g(t, u) {
   t.isTTY && t.setRawMode(u);
 }
 var V = /* @__PURE__ */ new Map([["k", "up"], ["j", "down"], ["h", "left"], ["l", "right"]]);
 var tD = /* @__PURE__ */ new Set(["up", "down", "left", "right", "space", "enter"]);
 var h = class {
-  constructor({ render: u, input: F = import_node_process2.stdin, output: e = import_node_process2.stdout, ...s }, C = true) {
+  constructor({ render: u, input: F = import_node_process.stdin, output: e = import_node_process.stdout, ...s }, C = true) {
     this._track = false, this._cursor = 0, this.state = "initial", this.error = "", this.subscribers = /* @__PURE__ */ new Map(), this._prevFrame = "", this.opts = s, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = u.bind(this), this._track = C, this.input = F, this.output = e;
   }
   prompt() {
-    const u = new import_node_tty2.WriteStream(0);
+    const u = new import_node_tty.WriteStream(0);
     return u._write = (F, e, s) => {
       this._track && (this.value = this.rl.line.replace(/\t/g, ""), this._cursor = this.rl.cursor, this.emit("value", this.value)), s();
     }, this.input.pipe(u), this.rl = import_node_readline.default.createInterface({ input: this.input, output: u, tabSize: 2, prompt: "", escapeCodeTimeout: 50 }), import_node_readline.default.emitKeypressEvents(this.input, this.rl), this.rl.prompt(), this.opts.initialValue !== void 0 && this._track && this.rl.write(this.opts.initialValue), this.input.on("keypress", this.onKeypress), g(this.input, true), this.output.on("resize", this.render), this.render(), new Promise((F, e) => {
@@ -56196,6 +57266,38 @@ var sD = class extends h {
     });
   }
 };
+var iD = class extends h {
+  constructor(u) {
+    super(u, false), this.cursor = 0, this.options = u.options, this.value = [...u.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: F }) => F === u.cursorAt), 0), this.on("key", (F) => {
+      F === "a" && this.toggleAll();
+    }), this.on("cursor", (F) => {
+      switch (F) {
+        case "left":
+        case "up":
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          break;
+        case "down":
+        case "right":
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+  get _value() {
+    return this.options[this.cursor].value;
+  }
+  toggleAll() {
+    const u = this.value.length === this.options.length;
+    this.value = u ? [] : this.options.map((F) => F.value);
+  }
+  toggleValue() {
+    const u = this.value.includes(this._value);
+    this.value = u ? this.value.filter((F) => F !== this._value) : [...this.value, this._value];
+  }
+};
 var ED = class extends h {
   constructor(u) {
     super(u, false), this.cursor = 0, this.options = u.options, this.cursor = this.options.findIndex(({ value: F }) => F === u.initialValue), this.cursor === -1 && (this.cursor = 0), this.changeValue(), this.on("cursor", (F) => {
@@ -56237,18 +57339,15 @@ var oD = class extends h {
   }
 };
 
-// ../../node_modules/.pnpm/ansi-escapes@6.2.0/node_modules/ansi-escapes/index.js
-var import_node_process3 = __toESM(require("node:process"), 1);
+// ../../node_modules/.pnpm/log-update@5.0.1/node_modules/log-update/index.js
+var import_node_process4 = __toESM(require("node:process"), 1);
+
+// ../../node_modules/.pnpm/ansi-escapes@5.0.0/node_modules/ansi-escapes/index.js
 var ESC = "\x1B[";
 var OSC = "\x1B]";
 var BEL = "\x07";
 var SEP = ";";
-var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
-var isTerminalApp = !isBrowser && import_node_process3.default.env.TERM_PROGRAM === "Apple_Terminal";
-var isWindows = !isBrowser && import_node_process3.default.platform === "win32";
-var cwdFunction = isBrowser ? () => {
-  throw new Error("`process.cwd()` only works in Node.js, not the browser.");
-} : import_node_process3.default.cwd;
+var isTerminalApp = process.env.TERM_PROGRAM === "Apple_Terminal";
 var ansiEscapes = {};
 ansiEscapes.cursorTo = (x2, y2) => {
   if (typeof x2 !== "number") {
@@ -56257,7 +57356,7 @@ ansiEscapes.cursorTo = (x2, y2) => {
   if (typeof y2 !== "number") {
     return ESC + (x2 + 1) + "G";
   }
-  return ESC + (y2 + 1) + SEP + (x2 + 1) + "H";
+  return ESC + (y2 + 1) + ";" + (x2 + 1) + "H";
 };
 ansiEscapes.cursorMove = (x2, y2) => {
   if (typeof x2 !== "number") {
@@ -56307,151 +57406,32 @@ ansiEscapes.eraseScreen = ESC + "2J";
 ansiEscapes.scrollUp = ESC + "S";
 ansiEscapes.scrollDown = ESC + "T";
 ansiEscapes.clearScreen = "\x1Bc";
-ansiEscapes.clearTerminal = isWindows ? `${ansiEscapes.eraseScreen}${ESC}0f` : `${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
-ansiEscapes.enterAlternativeScreen = ESC + "?1049h";
-ansiEscapes.exitAlternativeScreen = ESC + "?1049l";
-ansiEscapes.beep = BEL;
-ansiEscapes.link = (text, url) => [
-  OSC,
-  "8",
-  SEP,
-  SEP,
-  url,
-  BEL,
-  text,
-  OSC,
-  "8",
-  SEP,
-  SEP,
-  BEL
-].join("");
-ansiEscapes.image = (buffer, options = {}) => {
-  let returnValue = `${OSC}1337;File=inline=1`;
-  if (options.width) {
-    returnValue += `;width=${options.width}`;
-  }
-  if (options.height) {
-    returnValue += `;height=${options.height}`;
-  }
-  if (options.preserveAspectRatio === false) {
-    returnValue += ";preserveAspectRatio=0";
-  }
-  return returnValue + ":" + buffer.toString("base64") + BEL;
-};
-ansiEscapes.iTerm = {
-  setCwd: (cwd = cwdFunction()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
-  annotation(message, options = {}) {
-    let returnValue = `${OSC}1337;`;
-    const hasX = typeof options.x !== "undefined";
-    const hasY = typeof options.y !== "undefined";
-    if ((hasX || hasY) && !(hasX && hasY && typeof options.length !== "undefined")) {
-      throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
-    }
-    message = message.replace(/\|/g, "");
-    returnValue += options.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
-    if (options.length > 0) {
-      returnValue += (hasX ? [message, options.length, options.x, options.y] : [options.length, message]).join("|");
-    } else {
-      returnValue += message;
-    }
-    return returnValue + BEL;
-  }
-};
-var ansi_escapes_default = ansiEscapes;
-
-// ../../node_modules/.pnpm/log-update@5.0.1/node_modules/log-update/index.js
-var import_node_process6 = __toESM(require("node:process"), 1);
-
-// ../../node_modules/.pnpm/ansi-escapes@5.0.0/node_modules/ansi-escapes/index.js
-var ESC2 = "\x1B[";
-var OSC2 = "\x1B]";
-var BEL2 = "\x07";
-var SEP2 = ";";
-var isTerminalApp2 = process.env.TERM_PROGRAM === "Apple_Terminal";
-var ansiEscapes2 = {};
-ansiEscapes2.cursorTo = (x2, y2) => {
-  if (typeof x2 !== "number") {
-    throw new TypeError("The `x` argument is required");
-  }
-  if (typeof y2 !== "number") {
-    return ESC2 + (x2 + 1) + "G";
-  }
-  return ESC2 + (y2 + 1) + ";" + (x2 + 1) + "H";
-};
-ansiEscapes2.cursorMove = (x2, y2) => {
-  if (typeof x2 !== "number") {
-    throw new TypeError("The `x` argument is required");
-  }
-  let returnValue = "";
-  if (x2 < 0) {
-    returnValue += ESC2 + -x2 + "D";
-  } else if (x2 > 0) {
-    returnValue += ESC2 + x2 + "C";
-  }
-  if (y2 < 0) {
-    returnValue += ESC2 + -y2 + "A";
-  } else if (y2 > 0) {
-    returnValue += ESC2 + y2 + "B";
-  }
-  return returnValue;
-};
-ansiEscapes2.cursorUp = (count = 1) => ESC2 + count + "A";
-ansiEscapes2.cursorDown = (count = 1) => ESC2 + count + "B";
-ansiEscapes2.cursorForward = (count = 1) => ESC2 + count + "C";
-ansiEscapes2.cursorBackward = (count = 1) => ESC2 + count + "D";
-ansiEscapes2.cursorLeft = ESC2 + "G";
-ansiEscapes2.cursorSavePosition = isTerminalApp2 ? "\x1B7" : ESC2 + "s";
-ansiEscapes2.cursorRestorePosition = isTerminalApp2 ? "\x1B8" : ESC2 + "u";
-ansiEscapes2.cursorGetPosition = ESC2 + "6n";
-ansiEscapes2.cursorNextLine = ESC2 + "E";
-ansiEscapes2.cursorPrevLine = ESC2 + "F";
-ansiEscapes2.cursorHide = ESC2 + "?25l";
-ansiEscapes2.cursorShow = ESC2 + "?25h";
-ansiEscapes2.eraseLines = (count) => {
-  let clear = "";
-  for (let i = 0; i < count; i++) {
-    clear += ansiEscapes2.eraseLine + (i < count - 1 ? ansiEscapes2.cursorUp() : "");
-  }
-  if (count) {
-    clear += ansiEscapes2.cursorLeft;
-  }
-  return clear;
-};
-ansiEscapes2.eraseEndLine = ESC2 + "K";
-ansiEscapes2.eraseStartLine = ESC2 + "1K";
-ansiEscapes2.eraseLine = ESC2 + "2K";
-ansiEscapes2.eraseDown = ESC2 + "J";
-ansiEscapes2.eraseUp = ESC2 + "1J";
-ansiEscapes2.eraseScreen = ESC2 + "2J";
-ansiEscapes2.scrollUp = ESC2 + "S";
-ansiEscapes2.scrollDown = ESC2 + "T";
-ansiEscapes2.clearScreen = "\x1Bc";
-ansiEscapes2.clearTerminal = process.platform === "win32" ? `${ansiEscapes2.eraseScreen}${ESC2}0f` : (
+ansiEscapes.clearTerminal = process.platform === "win32" ? `${ansiEscapes.eraseScreen}${ESC}0f` : (
   // 1. Erases the screen (Only done in case `2` is not supported)
   // 2. Erases the whole screen including scrollback buffer
   // 3. Moves cursor to the top-left position
   // More info: https://www.real-world-systems.com/docs/ANSIcode.html
-  `${ansiEscapes2.eraseScreen}${ESC2}3J${ESC2}H`
+  `${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`
 );
-ansiEscapes2.beep = BEL2;
-ansiEscapes2.link = (text, url) => {
+ansiEscapes.beep = BEL;
+ansiEscapes.link = (text, url) => {
   return [
-    OSC2,
+    OSC,
     "8",
-    SEP2,
-    SEP2,
+    SEP,
+    SEP,
     url,
-    BEL2,
+    BEL,
     text,
-    OSC2,
+    OSC,
     "8",
-    SEP2,
-    SEP2,
-    BEL2
+    SEP,
+    SEP,
+    BEL
   ].join("");
 };
-ansiEscapes2.image = (buffer, options = {}) => {
-  let returnValue = `${OSC2}1337;File=inline=1`;
+ansiEscapes.image = (buffer, options = {}) => {
+  let returnValue = `${OSC}1337;File=inline=1`;
   if (options.width) {
     returnValue += `;width=${options.width}`;
   }
@@ -56461,12 +57441,12 @@ ansiEscapes2.image = (buffer, options = {}) => {
   if (options.preserveAspectRatio === false) {
     returnValue += ";preserveAspectRatio=0";
   }
-  return returnValue + ":" + buffer.toString("base64") + BEL2;
+  return returnValue + ":" + buffer.toString("base64") + BEL;
 };
-ansiEscapes2.iTerm = {
-  setCwd: (cwd = process.cwd()) => `${OSC2}50;CurrentDir=${cwd}${BEL2}`,
+ansiEscapes.iTerm = {
+  setCwd: (cwd = process.cwd()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
   annotation: (message, options = {}) => {
-    let returnValue = `${OSC2}1337;`;
+    let returnValue = `${OSC}1337;`;
     const hasX = typeof options.x !== "undefined";
     const hasY = typeof options.y !== "undefined";
     if ((hasX || hasY) && !(hasX && hasY && typeof options.length !== "undefined")) {
@@ -56479,21 +57459,21 @@ ansiEscapes2.iTerm = {
     } else {
       returnValue += message;
     }
-    return returnValue + BEL2;
+    return returnValue + BEL;
   }
 };
-var ansi_escapes_default2 = ansiEscapes2;
+var ansi_escapes_default = ansiEscapes;
 
 // ../../node_modules/.pnpm/cli-cursor@4.0.0/node_modules/cli-cursor/index.js
-var import_node_process5 = __toESM(require("node:process"), 1);
+var import_node_process3 = __toESM(require("node:process"), 1);
 
 // ../../node_modules/.pnpm/restore-cursor@4.0.0/node_modules/restore-cursor/index.js
-var import_node_process4 = __toESM(require("node:process"), 1);
+var import_node_process2 = __toESM(require("node:process"), 1);
 var import_onetime = __toESM(require_onetime(), 1);
 var import_signal_exit = __toESM(require_signal_exit(), 1);
 var restoreCursor = (0, import_onetime.default)(() => {
   (0, import_signal_exit.default)(() => {
-    import_node_process4.default.stderr.write("\x1B[?25h");
+    import_node_process2.default.stderr.write("\x1B[?25h");
   }, { alwaysLast: true });
 });
 var restore_cursor_default = restoreCursor;
@@ -56501,14 +57481,14 @@ var restore_cursor_default = restoreCursor;
 // ../../node_modules/.pnpm/cli-cursor@4.0.0/node_modules/cli-cursor/index.js
 var isHidden = false;
 var cliCursor = {};
-cliCursor.show = (writableStream = import_node_process5.default.stderr) => {
+cliCursor.show = (writableStream = import_node_process3.default.stderr) => {
   if (!writableStream.isTTY) {
     return;
   }
   isHidden = false;
   writableStream.write("\x1B[?25h");
 };
-cliCursor.hide = (writableStream = import_node_process5.default.stderr) => {
+cliCursor.hide = (writableStream = import_node_process3.default.stderr) => {
   if (!writableStream.isTTY) {
     return;
   }
@@ -56589,11 +57569,11 @@ function stringWidth(string, options = {}) {
 }
 
 // ../../node_modules/.pnpm/ansi-styles@6.2.1/node_modules/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET2 = 10;
-var wrapAnsi162 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi2562 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m2 = (offset = 0) => (red2, green2, blue2) => `\x1B[${38 + offset};2;${red2};${green2};${blue2}m`;
-var styles3 = {
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red2, green2, blue2) => `\x1B[${38 + offset};2;${red2};${green2};${blue2}m`;
+var styles = {
   modifier: {
     reset: [0, 0],
     // 21 isn't widely supported and 22 does the same thing
@@ -56653,39 +57633,39 @@ var styles3 = {
     bgWhiteBright: [107, 49]
   }
 };
-var modifierNames2 = Object.keys(styles3.modifier);
-var foregroundColorNames2 = Object.keys(styles3.color);
-var backgroundColorNames2 = Object.keys(styles3.bgColor);
-var colorNames2 = [...foregroundColorNames2, ...backgroundColorNames2];
-function assembleStyles2() {
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
   const codes = /* @__PURE__ */ new Map();
-  for (const [groupName, group] of Object.entries(styles3)) {
+  for (const [groupName, group] of Object.entries(styles)) {
     for (const [styleName, style] of Object.entries(group)) {
-      styles3[styleName] = {
+      styles[styleName] = {
         open: `\x1B[${style[0]}m`,
         close: `\x1B[${style[1]}m`
       };
-      group[styleName] = styles3[styleName];
+      group[styleName] = styles[styleName];
       codes.set(style[0], style[1]);
     }
-    Object.defineProperty(styles3, groupName, {
+    Object.defineProperty(styles, groupName, {
       value: group,
       enumerable: false
     });
   }
-  Object.defineProperty(styles3, "codes", {
+  Object.defineProperty(styles, "codes", {
     value: codes,
     enumerable: false
   });
-  styles3.color.close = "\x1B[39m";
-  styles3.bgColor.close = "\x1B[49m";
-  styles3.color.ansi = wrapAnsi162();
-  styles3.color.ansi256 = wrapAnsi2562();
-  styles3.color.ansi16m = wrapAnsi16m2();
-  styles3.bgColor.ansi = wrapAnsi162(ANSI_BACKGROUND_OFFSET2);
-  styles3.bgColor.ansi256 = wrapAnsi2562(ANSI_BACKGROUND_OFFSET2);
-  styles3.bgColor.ansi16m = wrapAnsi16m2(ANSI_BACKGROUND_OFFSET2);
-  Object.defineProperties(styles3, {
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
     rgbToAnsi256: {
       value: (red2, green2, blue2) => {
         if (red2 === green2 && green2 === blue2) {
@@ -56723,7 +57703,7 @@ function assembleStyles2() {
       enumerable: false
     },
     hexToAnsi256: {
-      value: (hex) => styles3.rgbToAnsi256(...styles3.hexToRgb(hex)),
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
       enumerable: false
     },
     ansi256ToAnsi: {
@@ -56761,18 +57741,18 @@ function assembleStyles2() {
       enumerable: false
     },
     rgbToAnsi: {
-      value: (red2, green2, blue2) => styles3.ansi256ToAnsi(styles3.rgbToAnsi256(red2, green2, blue2)),
+      value: (red2, green2, blue2) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red2, green2, blue2)),
       enumerable: false
     },
     hexToAnsi: {
-      value: (hex) => styles3.ansi256ToAnsi(styles3.hexToAnsi256(hex)),
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
       enumerable: false
     }
   });
-  return styles3;
+  return styles;
 }
-var ansiStyles2 = assembleStyles2();
-var ansi_styles_default2 = ansiStyles2;
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
 
 // ../../node_modules/.pnpm/wrap-ansi@8.1.0/node_modules/wrap-ansi/index.js
 var ESCAPES = /* @__PURE__ */ new Set([
@@ -56902,7 +57882,7 @@ var exec = (string, columns, options = {}) => {
         escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
       }
     }
-    const code = ansi_styles_default2.codes.get(Number(escapeCode));
+    const code = ansi_styles_default.codes.get(Number(escapeCode));
     if (pre[index + 1] === "\n") {
       if (escapeUrl) {
         returnValue += wrapAnsiHyperlink("");
@@ -56963,7 +57943,7 @@ var checkAnsi = (ansiCodes, isEscapes, endAnsiCode) => {
     if (ansiCode.includes(";")) {
       ansiCode = ansiCode.split(";")[0][0] + "0";
     }
-    const item = ansi_styles_default2.codes.get(Number.parseInt(ansiCode, 10));
+    const item = ansi_styles_default.codes.get(Number.parseInt(ansiCode, 10));
     if (item) {
       const indexEscape = ansiCodes.indexOf(item.toString());
       if (indexEscape === -1) {
@@ -56981,7 +57961,7 @@ var checkAnsi = (ansiCodes, isEscapes, endAnsiCode) => {
   if (isEscapes) {
     output = output.filter((element, index) => output.indexOf(element) === index);
     if (endAnsiCode !== void 0) {
-      const fistEscapeCode = wrapAnsi2(ansi_styles_default2.codes.get(Number.parseInt(endAnsiCode, 10)));
+      const fistEscapeCode = wrapAnsi2(ansi_styles_default.codes.get(Number.parseInt(endAnsiCode, 10)));
       output = output.reduce((current, next) => next === fistEscapeCode ? [next, ...current] : [...current, next], []);
     }
   }
@@ -57073,11 +58053,11 @@ function createLogUpdate(stream, { showCursor = false } = {}) {
       hard: true,
       wordWrap: false
     });
-    stream.write(ansi_escapes_default2.eraseLines(previousLineCount) + output);
+    stream.write(ansi_escapes_default.eraseLines(previousLineCount) + output);
     previousLineCount = output.split("\n").length;
   };
   render.clear = () => {
-    stream.write(ansi_escapes_default2.eraseLines(previousLineCount));
+    stream.write(ansi_escapes_default.eraseLines(previousLineCount));
     previousOutput = "";
     previousWidth = getWidth(stream);
     previousLineCount = 0;
@@ -57092,11 +58072,59 @@ function createLogUpdate(stream, { showCursor = false } = {}) {
   };
   return render;
 }
-var logUpdate = createLogUpdate(import_node_process6.default.stdout);
-var logUpdateStderr = createLogUpdate(import_node_process6.default.stderr);
+var logUpdate = createLogUpdate(import_node_process4.default.stdout);
+var logUpdateStderr = createLogUpdate(import_node_process4.default.stderr);
+
+// ../cli/select-list.ts
+var SelectRefreshablePrompt = class extends h {
+  options;
+  cursor = 0;
+  get _value() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    this.value = this._value.value;
+  }
+  constructor(opts) {
+    super(opts, false);
+    this.options = opts.options;
+    this.cursor = this.options.findIndex(
+      ({ value }) => value === opts.initialValue
+    );
+    if (this.cursor === -1)
+      this.cursor = 0;
+    this.changeValue();
+    this.on("key", (c2) => {
+      if (c2 !== "r")
+        return;
+      void opts.onRefresh().then((newOptions) => {
+        this.options = [...newOptions];
+        this.cursor = 0;
+        this.changeValue();
+        const that = this;
+        if ("render" in that && typeof that.render === "function") {
+          that.render();
+        }
+      }).catch(() => {
+      });
+    });
+    this.on("cursor", (key) => {
+      switch (key) {
+        case "left":
+        case "up":
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          break;
+        case "down":
+        case "right":
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
 
 // ../cli/interactive.ts
-process.stdout.columns = 300;
 var logUpdate2 = createLogUpdate(process.stdout);
 var grayBar = gray(shapes.bar);
 var blCorner = gray(shapes.corners.bl);
@@ -57104,8 +58132,8 @@ var leftT = gray(shapes.leftT);
 var inputPrompt = async (promptConfig) => {
   const renderers = getRenderers(promptConfig);
   let prompt;
-  const dispatchRender = (props) => {
-    const renderedLines = renderers[props.state](props);
+  const dispatchRender = (props, p2) => {
+    const renderedLines = renderers[props.state](props, p2);
     return renderedLines.join("\n");
   };
   if (promptConfig.type === "select") {
@@ -57113,7 +58141,7 @@ var inputPrompt = async (promptConfig) => {
       ...promptConfig,
       initialValue: String(promptConfig.defaultValue),
       render() {
-        return dispatchRender(this);
+        return dispatchRender(this, prompt);
       }
     });
   } else if (promptConfig.type === "confirm") {
@@ -57123,28 +58151,59 @@ var inputPrompt = async (promptConfig) => {
       active: promptConfig.activeText || "",
       inactive: promptConfig.inactiveText || "",
       render() {
-        return dispatchRender(this);
+        return dispatchRender(this, prompt);
+      }
+    });
+  } else if (promptConfig.type == "multiselect") {
+    let initialValues;
+    if (Array.isArray(promptConfig.defaultValue)) {
+      initialValues = promptConfig.defaultValue;
+    } else if (promptConfig.defaultValue !== void 0) {
+      initialValues = [String(promptConfig.defaultValue)];
+    }
+    prompt = new iD({
+      ...promptConfig,
+      options: promptConfig.options,
+      initialValues,
+      render() {
+        return dispatchRender(this, prompt);
+      }
+    });
+  } else if (promptConfig.type === "list") {
+    prompt = new SelectRefreshablePrompt({
+      ...promptConfig,
+      onRefresh: promptConfig.onRefresh ?? (() => Promise.resolve(promptConfig.options)),
+      initialValue: String(promptConfig.defaultValue),
+      render() {
+        return dispatchRender(this, prompt);
       }
     });
   } else {
     prompt = new oD({
       ...promptConfig,
+      initialValue: promptConfig.initialValue,
       defaultValue: String(promptConfig.defaultValue),
       render() {
-        return dispatchRender(this);
+        return dispatchRender(this, prompt);
       }
     });
   }
   const input = await prompt.prompt();
+  if (eD(input)) {
+    cancel("Operation cancelled.");
+    process.exit(0);
+  }
   return input;
 };
 var renderSubmit = (config14, value) => {
   const { question, label } = config14;
+  if (config14.type !== "confirm" && value.length === 0) {
+    return [`${leftT} ${question} ${dim("(skipped)")}`, `${grayBar}`];
+  }
   const content = config14.type === "confirm" ? `${grayBar} ${brandColor(value)} ${dim(label)}` : `${grayBar} ${brandColor(label)} ${dim(value)}`;
   return [`${leftT} ${question}`, content, `${grayBar}`];
 };
 var handleCancel = () => {
-  process.stdout.write(ansi_escapes_default.cursorShow);
   cancel("Operation cancelled.");
   process.exit(0);
 };
@@ -57156,6 +58215,10 @@ var getRenderers = (config14) => {
       return getConfirmRenderers(config14);
     case "text":
       return getTextRenderers(config14);
+    case "multiselect":
+      return getSelectRenderers(config14);
+    case "list":
+      return getSelectListRenderers(config14);
   }
 };
 var getTextRenderers = (config14) => {
@@ -57176,12 +58239,14 @@ var getTextRenderers = (config14) => {
     ],
     active: ({ value }) => [
       `${blCorner} ${bold(question)} ${dim(helpText)}`,
-      `${space(2)}${format3(value || dim(defaultValue))}`,
+      `${space(2)}${format3(
+        value || dim(typeof defaultValue === "string" ? defaultValue : ``)
+      )}`,
       ``
       // extra line for readability
     ],
-    error: ({ value, error }) => [
-      `${leftT} ${status.error} ${dim(error)}`,
+    error: ({ value, error: error2 }) => [
+      `${leftT} ${status.error} ${dim(error2)}`,
       `${grayBar}`,
       `${blCorner} ${question} ${dim(helpText)}`,
       `${space(2)}${format3(value)}`,
@@ -57195,18 +58260,34 @@ var getTextRenderers = (config14) => {
 var getSelectRenderers = (config14) => {
   const { options, question, helpText: _helpText } = config14;
   const helpText = _helpText ?? "";
-  const defaultRenderer = ({ cursor }) => {
+  const maxItemsPerPage = config14.maxItemsPerPage ?? 32;
+  const defaultRenderer = ({ cursor, value }) => {
+    cursor = cursor ?? 0;
     const renderOption = (opt, i) => {
-      const { label: optionLabel } = opt;
+      const { label: optionLabel, value: optionValue } = opt;
       const active = i === cursor;
-      const text = active ? blue.underline(optionLabel) : dim(optionLabel);
-      const indicator = active ? blue(shapes.radioActive) : dim(shapes.radioInactive);
+      const isInListOfValues = Array.isArray(value) && value.includes(optionValue);
+      const color = isInListOfValues || active ? blue : dim;
+      const text = active ? color.underline(optionLabel) : color(optionLabel);
+      const indicator = isInListOfValues || active && !Array.isArray(value) ? color(shapes.radioActive) : color(shapes.radioInactive);
       return `${space(2)}${indicator} ${text}`;
     };
+    const renderOptionCondition = (_2, i) => {
+      if (options.length <= maxItemsPerPage) {
+        return true;
+      }
+      cursor = cursor ?? 0;
+      if (i < cursor) {
+        return options.length - i <= maxItemsPerPage;
+      }
+      return cursor + maxItemsPerPage > i;
+    };
     return [
       `${blCorner} ${bold(question)} ${dim(helpText)}`,
-      `${options.filter((o) => !o.hidden).map(renderOption).join(`
-`)}`,
+      `${cursor > 0 && options.length > maxItemsPerPage ? `${space(2)}${dim("...")}
+` : ""}${options.filter((o) => !o.hidden).map(renderOption).filter(renderOptionCondition).join(`
+`)}${cursor + maxItemsPerPage < options.length && options.length > maxItemsPerPage ? `
+${space(2)}${dim("...")}` : ""}`,
       ``
       // extra line for readability
     ];
@@ -57215,11 +58296,120 @@ var getSelectRenderers = (config14) => {
     initial: defaultRenderer,
     active: defaultRenderer,
     confirm: defaultRenderer,
-    error: defaultRenderer,
-    submit: ({ value }) => renderSubmit(
-      config14,
-      options.find((o) => o.value === value)?.label
-    ),
+    error: (opts, prompt) => {
+      return [
+        `${leftT} ${status.error} ${dim(opts.error)}`,
+        `${grayBar}`,
+        ...defaultRenderer(opts, prompt)
+      ];
+    },
+    submit: ({ value }) => {
+      if (Array.isArray(value)) {
+        return renderSubmit(
+          config14,
+          options.filter((o) => value.includes(o.value)).map((o) => o.label).join(", ")
+        );
+      }
+      return renderSubmit(
+        config14,
+        options.find((o) => o.value === value)?.label
+      );
+    },
+    cancel: handleCancel
+  };
+};
+var getSelectListRenderers = (config14) => {
+  const { question, helpText: _helpText } = config14;
+  let options = config14.options;
+  const helpText = _helpText ?? "";
+  const { rows } = process.stdout;
+  const defaultRenderer = ({ cursor, value }, prompt) => {
+    if (prompt instanceof SelectRefreshablePrompt) {
+      options = prompt.options;
+    }
+    cursor = cursor ?? 0;
+    let smallCursor = 0;
+    const renderOption = (opt, i) => {
+      const { label: optionLabel, value: optionValueAny } = opt;
+      const optionValue = optionValueAny.toString();
+      const active = i === smallCursor;
+      const isInListOfValues = Array.isArray(value) && value.includes(optionValue);
+      const color = isInListOfValues || active ? blue : white;
+      const text = active ? color.underline(optionLabel) : color(optionLabel);
+      const indicator = isInListOfValues || active && !Array.isArray(value) ? color(shapes.radioActive) : color(shapes.radioInactive);
+      const indicatorMargin = 2;
+      const detailBulletpointMargin = indicatorMargin + 4;
+      return [
+        `${space(indicatorMargin)}${indicator} ${text}`,
+        ...opt.details.map(
+          (detail, j2) => `${space(detailBulletpointMargin)}${j2 === opt.details.length - 1 ? gray(shapes.corners.bl) : grayBar} ${detail}`
+        )
+      ];
+    };
+    const pages = [];
+    let current = {
+      size: 0,
+      options: []
+    };
+    const VERTICAL_MARGIN = 6;
+    for (const option of options) {
+      const optionHeight = option.details.length + 1;
+      if (current.size + optionHeight > rows - VERTICAL_MARGIN) {
+        pages.push(current.options);
+        current = { size: optionHeight, options: [option] };
+        continue;
+      }
+      current.size += optionHeight;
+      current.options.push(option);
+    }
+    if (current.size !== 0) {
+      pages.push(current.options);
+    }
+    let isFirstPage = true;
+    let isLastPage = false;
+    let page = [];
+    let len = 0;
+    for (let i = 0; i < pages.length; i++) {
+      const pageIter = pages[i];
+      if (cursor >= len && pageIter.length + len > cursor) {
+        isFirstPage = i === 0;
+        isLastPage = i === pages.length - 1;
+        page = pageIter;
+        smallCursor = cursor - len;
+        break;
+      }
+      len += pageIter.length;
+    }
+    return [
+      `${blCorner} ${bold(question)} ${dim(helpText)}`,
+      ...!isFirstPage ? [`${space(2)}${dim("...")}`] : [],
+      ...page.map(renderOption).reduce((prev, now) => [...prev, ...now], []),
+      ...!isLastPage ? [`${space(2)}${dim("...")}`] : []
+    ];
+  };
+  return {
+    initial: defaultRenderer,
+    active: defaultRenderer,
+    confirm: defaultRenderer,
+    error: (opts, prompt) => {
+      return [
+        `${leftT} ${status.error} ${dim(opts.error)}`,
+        `${grayBar}`,
+        ...defaultRenderer(opts, prompt)
+      ];
+    },
+    submit: ({ value }) => {
+      if (Array.isArray(value)) {
+        return renderSubmit(
+          config14,
+          options.filter((o) => value.includes(o.value)).map((o) => o.value).join(", ")
+        );
+      }
+      return renderSubmit(
+        config14,
+        options.find((o) => o.value === value)?.value
+      );
+    },
     cancel: handleCancel
   };
 };
@@ -57229,8 +58419,8 @@ var getConfirmRenderers = (config14) => {
   const active = activeText || "Yes";
   const inactive = inactiveText || "No";
   const defaultRenderer = ({ value }) => {
-    const yesColor = value ? blue : dim;
-    const noColor = value ? dim : blue;
+    const yesColor = value ? blue.underline : dim;
+    const noColor = value ? dim : blue.underline;
     return [
       `${blCorner} ${bold(question)} ${dim(helpText)}`,
       `${space(2)}${yesColor(active)} / ${noColor(inactive)}`
@@ -57306,6 +58496,23 @@ var isInteractive = () => {
   return process.stdin.isTTY;
 };
 
+// ../cli/args.ts
+var processArgument = async (args, name2, promptConfig) => {
+  let value = args[name2];
+  const renderSubmitted = getRenderers(promptConfig).submit;
+  if (value !== void 0) {
+    const error2 = promptConfig.validate?.(value);
+    if (error2) {
+      crash(error2);
+    }
+    const lines = renderSubmitted({ value });
+    logRaw(lines.join("\n"));
+    return value;
+  }
+  value = await inputPrompt(promptConfig);
+  return value;
+};
+
 // ../../node_modules/.pnpm/yargs@17.7.1/node_modules/yargs/lib/platform-shims/esm.mjs
 var import_assert = require("assert");
 
@@ -57863,7 +59070,7 @@ var YargsParser = class {
         defaults[alias] = defaults[key];
       });
     });
-    let error = null;
+    let error2 = null;
     checkConfiguration();
     let notFlags = [];
     const argv = Object.assign(/* @__PURE__ */ Object.create(null), { _: [] });
@@ -58047,7 +59254,7 @@ var YargsParser = class {
       toEat = typeof toEat !== "number" || isNaN(toEat) ? 1 : toEat;
       if (toEat === 0) {
         if (!isUndefined(argAfterEqualSign)) {
-          error = Error(__("Argument unexpected for: %s", key));
+          error2 = Error(__("Argument unexpected for: %s", key));
         }
         setArg(key, defaultValue(key));
         return i;
@@ -58055,7 +59262,7 @@ var YargsParser = class {
       let available = isUndefined(argAfterEqualSign) ? 0 : 1;
       if (configuration["nargs-eats-options"]) {
         if (args2.length - (i + 1) + available < toEat) {
-          error = Error(__("Not enough arguments following: %s", key));
+          error2 = Error(__("Not enough arguments following: %s", key));
         }
         available = toEat;
       } else {
@@ -58066,7 +59273,7 @@ var YargsParser = class {
             break;
         }
         if (available < toEat)
-          error = Error(__("Not enough arguments following: %s", key));
+          error2 = Error(__("Not enough arguments following: %s", key));
       }
       let consumed = Math.min(available, toEat);
       if (!isUndefined(argAfterEqualSign) && consumed > 0) {
@@ -58104,7 +59311,7 @@ var YargsParser = class {
         }
       }
       if (typeof nargsCount === "number" && (nargsCount && argsToSet.length < nargsCount || isNaN(nargsCount) && argsToSet.length === 0)) {
-        error = Error(__("Not enough arguments following: %s", key));
+        error2 = Error(__("Not enough arguments following: %s", key));
       }
       setArg(key, argsToSet);
       return i;
@@ -58213,7 +59420,7 @@ var YargsParser = class {
                 config14 = e;
               }
               if (config14 instanceof Error) {
-                error = config14;
+                error2 = config14;
                 return;
               }
             } else {
@@ -58222,9 +59429,9 @@ var YargsParser = class {
             setConfigObject(config14);
           } catch (ex) {
             if (ex.name === "PermissionDenied")
-              error = ex;
+              error2 = ex;
             else if (argv2[configKey])
-              error = Error(__("Invalid JSON config file: %s", configPath));
+              error2 = Error(__("Invalid JSON config file: %s", configPath));
           }
         }
       });
@@ -58253,8 +59460,8 @@ var YargsParser = class {
       if (typeof envPrefix === "undefined")
         return;
       const prefix = typeof envPrefix === "string" ? envPrefix : "";
-      const env3 = mixin2.env();
-      Object.keys(env3).forEach(function(envVar) {
+      const env2 = mixin2.env();
+      Object.keys(env2).forEach(function(envVar) {
         if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
           const keys = envVar.split("__").map(function(key, i) {
             if (i === 0) {
@@ -58263,7 +59470,7 @@ var YargsParser = class {
             return camelCase(key);
           });
           if ((configOnly && flags.configs[keys.join(".")] || !configOnly) && !hasKey2(argv2, keys)) {
-            setArg(keys.join("."), env3[envVar]);
+            setArg(keys.join("."), env2[envVar]);
           }
         }
       });
@@ -58282,7 +59489,7 @@ var YargsParser = class {
                 argv2[ali] = value;
               });
             } catch (err) {
-              error = err;
+              error2 = err;
             }
           }
         }
@@ -58495,10 +59702,10 @@ var YargsParser = class {
     function checkConfiguration() {
       Object.keys(flags.counts).find((key) => {
         if (checkAllAliases(key, flags.arrays)) {
-          error = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key));
+          error2 = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key));
           return true;
         } else if (checkAllAliases(key, flags.nargs)) {
-          error = Error(__("Invalid configuration: %s, opts.count excludes opts.narg.", key));
+          error2 = Error(__("Invalid configuration: %s, opts.count excludes opts.narg.", key));
           return true;
         }
         return false;
@@ -58509,7 +59716,7 @@ var YargsParser = class {
       argv: Object.assign(argvReturn, argv),
       configuration,
       defaulted: Object.assign({}, defaulted),
-      error,
+      error: error2,
       newAliases: Object.assign({}, newAliases)
     };
   }
@@ -58573,11 +59780,11 @@ if (nodeVersion) {
     throw Error(`yargs parser supports a minimum Node.js version of ${minNodeVersion}. Read our version support policy: https://github.com/yargs/yargs-parser#supported-nodejs-versions`);
   }
 }
-var env2 = process ? process.env : {};
+var env = process ? process.env : {};
 var parser = new YargsParser({
   cwd: process.cwd,
   env: () => {
-    return env2;
+    return env;
   },
   format: import_util.format,
   normalize: import_path2.normalize,
@@ -59285,9 +60492,9 @@ var CommandInstance = class {
         yargs.getInternalMethods().getUsageInstance().cacheHelpMessage();
       }
       if (isPromise(innerArgv) && !yargs.getInternalMethods().hasParseCallback()) {
-        innerArgv.catch((error) => {
+        innerArgv.catch((error2) => {
           try {
-            yargs.getInternalMethods().getUsageInstance().fail(null, error);
+            yargs.getInternalMethods().getUsageInstance().fail(null, error2);
           } catch (_err) {
           }
         });
@@ -62163,7 +63370,7 @@ var Yargs = YargsFactory(esm_default);
 var yargs_default = Yargs;
 
 // package.json
-var version = "2.9.1";
+var version = "2.9.2";
 var devDependencies = {
   "@babel/parser": "^7.21.3",
   "@babel/types": "^7.21.4",
@@ -62250,6 +63457,7 @@ var WRANGLER_DEFAULTS = {
   type: "hello-world",
   deploy: false
 };
+process.stdout.columns = 300;
 
 // src/helpers/packages.ts
 var import_semver = __toESM(require_semver2());
@@ -62406,7 +63614,7 @@ var isDomainResolvable = async (domain) => {
     const dns = new import_dns2.default({ nameServers });
     const res = await dns.resolve(domain, "A");
     return res.answers.length > 0;
-  } catch (error) {
+  } catch (error2) {
     return false;
   }
 };
@@ -62430,7 +63638,7 @@ function secondsSince(start) {
 var import_shell_quote = __toESM(require_shell_quote());
 
 // ../wrangler/package.json
-var version2 = "3.22.5";
+var version2 = "3.23.0";
 
 // src/common.ts
 var { name, npm } = detectPackageManager();
@@ -62570,9 +63778,9 @@ var runDeploy = async (ctx) => {
     crash("Failed to find deployment url.");
   }
   if (ctx.deployedUrl?.endsWith(".pages.dev")) {
-    const [proto2, hostname] = ctx.deployedUrl.split("://");
+    const [proto, hostname] = ctx.deployedUrl.split("://");
     const hostnameWithoutSHA1 = hostname.split(".").slice(-3).join(".");
-    ctx.deployedUrl = `${proto2}://${hostnameWithoutSHA1}`;
+    ctx.deployedUrl = `${proto}://${hostnameWithoutSHA1}`;
   }
 };
 var chooseAccount = async (ctx) => {
@@ -62864,15 +64072,15 @@ var import_toml = __toESM(require_toml());
 var writeFile2 = (path3, content) => {
   try {
     import_fs6.default.writeFileSync(path3, content);
-  } catch (error) {
-    crash(error);
+  } catch (error2) {
+    crash(error2);
   }
 };
 var readFile = (path3) => {
   try {
     return import_fs6.default.readFileSync(path3, "utf-8");
-  } catch (error) {
-    return crash(error);
+  } catch (error2) {
+    return crash(error2);
   }
 };
 var readJSON = (path3) => {
@@ -63019,25 +64227,25 @@ var retry = async ({
   times,
   exitCondition
 }, fn) => {
-  let error = null;
+  let error2 = null;
   while (times > 0) {
     try {
       return await fn();
     } catch (e) {
-      error = e;
+      error2 = e;
       times--;
       if (exitCondition?.(e)) {
         break;
       }
     }
   }
-  throw error;
+  throw error2;
 };
 var runFrameworkGenerator = async (ctx, args) => {
   const cli = getFrameworkCli(ctx, true);
   const { npm: npm14, dlx: dlx2 } = detectPackageManager();
   const cmd = [...npm14 === "yarn" ? ["npx"] : dlx2, cli, ...args];
-  const env3 = npm14 === "yarn" ? { npm_config_user_agent: "yarn" } : {};
+  const env2 = npm14 === "yarn" ? { npm_config_user_agent: "yarn" } : {};
   if (ctx.framework?.args?.length) {
     cmd.push(...ctx.framework.args);
   }
@@ -63049,7 +64257,7 @@ var runFrameworkGenerator = async (ctx, args) => {
     const flags = ctx.framework?.config.testFlags ?? [];
     cmd.push(...flags);
   }
-  await runCommand(cmd, { env: env3 });
+  await runCommand(cmd, { env: env2 });
 };
 var installPackages = async (packages, config14) => {
   const { npm: npm14 } = detectPackageManager();
@@ -63138,7 +64346,7 @@ var isLoggedIn = async () => {
       silent: true
     });
     return /You are logged in/.test(output);
-  } catch (error) {
+  } catch (error2) {
     return false;
   }
 };
@@ -63218,7 +64426,7 @@ function getLatestTypesEntrypoint(ctx) {
       return null;
     }
     return sorted[0];
-  } catch (error) {
+  } catch (error2) {
     return null;
   }
 }
@@ -63907,16 +65115,16 @@ var package_default = {
     "additionally it also contains a map that maps frameworks to their respective clis"
   ],
   dependencies: {
-    "create-astro": "4.6.0",
+    "create-astro": "4.7.1",
     "@angular/create": "17.0.6",
-    "create-docusaurus": "3.0.1",
+    "create-docusaurus": "3.1.0",
     "create-hono": "0.3.2",
     "create-next-app": "14.0.4",
-    "create-qwik": "1.3.2",
+    "create-qwik": "1.3.5",
     "create-react-app": "5.0.1",
-    "create-remix": "2.4.1",
+    "create-remix": "2.5.0",
     "create-solid": "0.3.10",
-    "create-svelte": "6.0.5",
+    "create-svelte": "6.0.6",
     "create-vue": "3.9.1",
     gatsby: "5.13.1",
     nuxi: "3.10.0"
@@ -64048,7 +65256,7 @@ var typescriptParser = __toESM(require_typescript2());
 var parseTs = (src) => {
   try {
     return recast.parse(src, { parser: typescriptParser });
-  } catch (error) {
+  } catch (error2) {
     crash("Error parsing ts template.");
   }
 };
@@ -64060,7 +65268,7 @@ var parseFile = (filePath) => {
     if (fileContents) {
       return recast.parse(fileContents, { parser: parser2 });
     }
-  } catch (error) {
+  } catch (error2) {
     crash(`Error parsing file: ${filePath}`);
   }
   return null;
@@ -64336,7 +65544,7 @@ var createProject = async (ctx) => {
         )}`
       })
     );
-  } catch (error) {
+  } catch (error2) {
     crash("Failed to create pages project. See output above.");
   }
   try {
@@ -64362,7 +65570,7 @@ var createProject = async (ctx) => {
       })
     );
     debug(`Validated pages project ${ctx.project.name}`);
-  } catch (error) {
+  } catch (error2) {
     crash("Pages project isn't ready yet. Please try deploying again later.");
   }
 };
@@ -64617,21 +65825,6 @@ var parseArgs = async (argv) => {
     ...args
   };
 };
-var processArgument = async (args, name2, promptConfig) => {
-  let value = args[name2];
-  const renderSubmitted = getRenderers(promptConfig).submit;
-  if (value !== void 0) {
-    const error = promptConfig.validate?.(value);
-    if (error) {
-      crash(error);
-    }
-    const lines = renderSubmitted({ value });
-    logRaw(lines.join("\n"));
-    return value;
-  }
-  value = await inputPrompt(promptConfig);
-  return value;
-};
 var showMoreInfoNote = () => {
   const c3CliArgsDocsPage = "https://developers.cloudflare.com/pages/get-started/c3/#cli-arguments";
   console.log(