@prisma/internals 6.6.0-integration-mcp.2 → 6.6.0-integration-engines-6-6-0-28-feat-orm-596-expose-model-grouping-on-dmmf-600968a1f46d3d8626cdd2c933cf04e50eb5219b.1

package/dist/{chunk-R4ZFFYJA.js → chunk-K5W6WZ6E.js}

@@ -26,21 +26,20 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_R4ZFFYJA_exports = {};
-__export(chunk_R4ZFFYJA_exports, {
+var chunk_K5W6WZ6E_exports = {};
+__export(chunk_K5W6WZ6E_exports, {
   getPackedPackage: () => getPackedPackage,
   readPackageUp: () => readPackageUp,
   require_p_map: () => require_p_map,
   toPath: () => toPath2
 });
-module.exports = __toCommonJS(chunk_R4ZFFYJA_exports);
-var import_chunk_URRVX2VQ = require("./chunk-URRVX2VQ.js");
+module.exports = __toCommonJS(chunk_K5W6WZ6E_exports);
+var import_chunk_VVPSLVOR = require("./chunk-VVPSLVOR.js");
 var import_chunk_KDP6C3CB = require("./chunk-KDP6C3CB.js");
 var import_chunk_UZTXEBTM = require("./chunk-UZTXEBTM.js");
-var import_chunk_2LOGW45F = require("./chunk-2LOGW45F.js");
+var import_chunk_JOIIWB3U = require("./chunk-JOIIWB3U.js");
 var import_chunk_MM4ARWWY = require("./chunk-MM4ARWWY.js");
 var import_chunk_5VQNKCKW = require("./chunk-5VQNKCKW.js");
-var import_chunk_DYV47NUW = require("./chunk-DYV47NUW.js");
 var import_chunk_4VNS5WPM = require("./chunk-4VNS5WPM.js");
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
@@ -3166,77 +3165,6 @@ var require_lib5 = (0, import_chunk_4VNS5WPM.__commonJS)({
     walk.Walker = Walker;
   }
 });
-var require_picocolors = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js"(exports, module2) {
-    "use strict";
-    var p = process || {};
-    var argv = p.argv || [];
-    var env = p.env || {};
-    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
-    var formatter = (open, close, replace = open) => (input) => {
-      let string = "" + input, index = string.indexOf(close, open.length);
-      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-    };
-    var replaceClose = (string, close, replace, index) => {
-      let result = "", cursor = 0;
-      do {
-        result += string.substring(cursor, index) + replace;
-        cursor = index + close.length;
-        index = string.indexOf(close, cursor);
-      } while (~index);
-      return result + string.substring(cursor);
-    };
-    var createColors = (enabled = isColorSupported) => {
-      let f = enabled ? formatter : () => String;
-      return {
-        isColorSupported: enabled,
-        reset: f("\x1B[0m", "\x1B[0m"),
-        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
-        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
-        italic: f("\x1B[3m", "\x1B[23m"),
-        underline: f("\x1B[4m", "\x1B[24m"),
-        inverse: f("\x1B[7m", "\x1B[27m"),
-        hidden: f("\x1B[8m", "\x1B[28m"),
-        strikethrough: f("\x1B[9m", "\x1B[29m"),
-        black: f("\x1B[30m", "\x1B[39m"),
-        red: f("\x1B[31m", "\x1B[39m"),
-        green: f("\x1B[32m", "\x1B[39m"),
-        yellow: f("\x1B[33m", "\x1B[39m"),
-        blue: f("\x1B[34m", "\x1B[39m"),
-        magenta: f("\x1B[35m", "\x1B[39m"),
-        cyan: f("\x1B[36m", "\x1B[39m"),
-        white: f("\x1B[37m", "\x1B[39m"),
-        gray: f("\x1B[90m", "\x1B[39m"),
-        bgBlack: f("\x1B[40m", "\x1B[49m"),
-        bgRed: f("\x1B[41m", "\x1B[49m"),
-        bgGreen: f("\x1B[42m", "\x1B[49m"),
-        bgYellow: f("\x1B[43m", "\x1B[49m"),
-        bgBlue: f("\x1B[44m", "\x1B[49m"),
-        bgMagenta: f("\x1B[45m", "\x1B[49m"),
-        bgCyan: f("\x1B[46m", "\x1B[49m"),
-        bgWhite: f("\x1B[47m", "\x1B[49m"),
-        blackBright: f("\x1B[90m", "\x1B[39m"),
-        redBright: f("\x1B[91m", "\x1B[39m"),
-        greenBright: f("\x1B[92m", "\x1B[39m"),
-        yellowBright: f("\x1B[93m", "\x1B[39m"),
-        blueBright: f("\x1B[94m", "\x1B[39m"),
-        magentaBright: f("\x1B[95m", "\x1B[39m"),
-        cyanBright: f("\x1B[96m", "\x1B[39m"),
-        whiteBright: f("\x1B[97m", "\x1B[39m"),
-        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
-        bgRedBright: f("\x1B[101m", "\x1B[49m"),
-        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
-        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
-        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
-        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
-        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
-        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
-      };
-    };
-    module2.exports = createColors();
-    module2.exports.createColors = createColors;
-  }
-});
 var require_js_tokens = (0, import_chunk_4VNS5WPM.__commonJS)({
   "../../node_modules/.pnpm/js-tokens@4.0.0/node_modules/js-tokens/index.js"(exports) {
     "use strict";
@@ -3258,51 +3186,1587 @@ var require_js_tokens = (0, import_chunk_4VNS5WPM.__commonJS)({
     };
   }
 });
-var require_lib6 = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/@babel+code-frame@7.26.2/node_modules/@babel/code-frame/lib/index.js"(exports) {
+var require_escape_string_regexp = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/escape-string-regexp@1.0.5/node_modules/escape-string-regexp/index.js"(exports, module2) {
     "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    var picocolors = require_picocolors();
-    var jsTokens = require_js_tokens();
-    var helperValidatorIdentifier = (0, import_chunk_UZTXEBTM.require_lib)();
-    function isColorSupported() {
-      return typeof process === "object" && (process.env.FORCE_COLOR === "0" || process.env.FORCE_COLOR === "false") ? false : picocolors.isColorSupported;
-    }
-    var compose = (f, g) => (v) => f(g(v));
-    function buildDefs(colors) {
+    var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+    module2.exports = function(str) {
+      if (typeof str !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      return str.replace(matchOperatorsRe, "\\$&");
+    };
+  }
+});
+var require_color_name = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/color-name@1.1.3/node_modules/color-name/index.js"(exports, 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]
+    };
+  }
+});
+var require_conversions = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/conversions.js"(exports, module2) {
+    "use strict";
+    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 r = rgb[0] / 255;
+      var g = rgb[1] / 255;
+      var b = rgb[2] / 255;
+      var min = Math.min(r, g, b);
+      var max = Math.max(r, g, b);
+      var delta = max - min;
+      var h;
+      var s;
+      var l;
+      if (max === min) {
+        h = 0;
+      } else if (r === max) {
+        h = (g - b) / delta;
+      } else if (g === max) {
+        h = 2 + (b - r) / delta;
+      } else if (b === max) {
+        h = 4 + (r - g) / delta;
+      }
+      h = Math.min(h * 60, 360);
+      if (h < 0) {
+        h += 360;
+      }
+      l = (min + max) / 2;
+      if (max === min) {
+        s = 0;
+      } else if (l <= 0.5) {
+        s = delta / (max + min);
+      } else {
+        s = delta / (2 - max - min);
+      }
+      return [h, s * 100, l * 100];
+    };
+    convert.rgb.hsv = function(rgb) {
+      var rdif;
+      var gdif;
+      var bdif;
+      var h;
+      var s;
+      var r = rgb[0] / 255;
+      var g = rgb[1] / 255;
+      var b = rgb[2] / 255;
+      var v = Math.max(r, g, b);
+      var diff = v - Math.min(r, g, b);
+      var diffc = function(c) {
+        return (v - c) / 6 / diff + 1 / 2;
+      };
+      if (diff === 0) {
+        h = s = 0;
+      } else {
+        s = diff / v;
+        rdif = diffc(r);
+        gdif = diffc(g);
+        bdif = diffc(b);
+        if (r === v) {
+          h = bdif - gdif;
+        } else if (g === v) {
+          h = 1 / 3 + rdif - bdif;
+        } else if (b === v) {
+          h = 2 / 3 + gdif - rdif;
+        }
+        if (h < 0) {
+          h += 1;
+        } else if (h > 1) {
+          h -= 1;
+        }
+      }
+      return [
+        h * 360,
+        s * 100,
+        v * 100
+      ];
+    };
+    convert.rgb.hwb = function(rgb) {
+      var r = rgb[0];
+      var g = rgb[1];
+      var b = rgb[2];
+      var h = convert.rgb.hsl(rgb)[0];
+      var w = 1 / 255 * Math.min(r, Math.min(g, b));
+      b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+      return [h, w * 100, b * 100];
+    };
+    convert.rgb.cmyk = function(rgb) {
+      var r = rgb[0] / 255;
+      var g = rgb[1] / 255;
+      var b = rgb[2] / 255;
+      var c;
+      var m;
+      var y;
+      var k;
+      k = Math.min(1 - r, 1 - g, 1 - b);
+      c = (1 - r - k) / (1 - k) || 0;
+      m = (1 - g - k) / (1 - k) || 0;
+      y = (1 - b - k) / (1 - k) || 0;
+      return [c * 100, m * 100, y * 100, k * 100];
+    };
+    function comparativeDistance(x, y) {
+      return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[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 r = rgb[0] / 255;
+      var g = rgb[1] / 255;
+      var b = rgb[2] / 255;
+      r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+      g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+      b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+      var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+      var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+      var z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+      return [x * 100, y * 100, z * 100];
+    };
+    convert.rgb.lab = function(rgb) {
+      var xyz = convert.rgb.xyz(rgb);
+      var x = xyz[0];
+      var y = xyz[1];
+      var z = xyz[2];
+      var l;
+      var a;
+      var b;
+      x /= 95.047;
+      y /= 100;
+      z /= 108.883;
+      x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+      y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+      z = z > 8856e-6 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+      l = 116 * y - 16;
+      a = 500 * (x - y);
+      b = 200 * (y - z);
+      return [l, a, b];
+    };
+    convert.hsl.rgb = function(hsl) {
+      var h = hsl[0] / 360;
+      var s = hsl[1] / 100;
+      var l = hsl[2] / 100;
+      var t1;
+      var t2;
+      var t3;
+      var rgb;
+      var val;
+      if (s === 0) {
+        val = l * 255;
+        return [val, val, val];
+      }
+      if (l < 0.5) {
+        t2 = l * (1 + s);
+      } else {
+        t2 = l + s - l * s;
+      }
+      t1 = 2 * l - t2;
+      rgb = [0, 0, 0];
+      for (var i = 0; i < 3; i++) {
+        t3 = h + 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 h = hsl[0];
+      var s = hsl[1] / 100;
+      var l = hsl[2] / 100;
+      var smin = s;
+      var lmin = Math.max(l, 0.01);
+      var sv;
+      var v;
+      l *= 2;
+      s *= l <= 1 ? l : 2 - l;
+      smin *= lmin <= 1 ? lmin : 2 - lmin;
+      v = (l + s) / 2;
+      sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+      return [h, sv * 100, v * 100];
+    };
+    convert.hsv.rgb = function(hsv) {
+      var h = hsv[0] / 60;
+      var s = hsv[1] / 100;
+      var v = hsv[2] / 100;
+      var hi = Math.floor(h) % 6;
+      var f = h - Math.floor(h);
+      var p = 255 * v * (1 - s);
+      var q = 255 * v * (1 - s * f);
+      var t = 255 * v * (1 - s * (1 - f));
+      v *= 255;
+      switch (hi) {
+        case 0:
+          return [v, t, p];
+        case 1:
+          return [q, v, p];
+        case 2:
+          return [p, v, t];
+        case 3:
+          return [p, q, v];
+        case 4:
+          return [t, p, v];
+        case 5:
+          return [v, p, q];
+      }
+    };
+    convert.hsv.hsl = function(hsv) {
+      var h = hsv[0];
+      var s = hsv[1] / 100;
+      var v = hsv[2] / 100;
+      var vmin = Math.max(v, 0.01);
+      var lmin;
+      var sl;
+      var l;
+      l = (2 - s) * v;
+      lmin = (2 - s) * vmin;
+      sl = s * vmin;
+      sl /= lmin <= 1 ? lmin : 2 - lmin;
+      sl = sl || 0;
+      l /= 2;
+      return [h, sl * 100, l * 100];
+    };
+    convert.hwb.rgb = function(hwb) {
+      var h = hwb[0] / 360;
+      var wh = hwb[1] / 100;
+      var bl = hwb[2] / 100;
+      var ratio = wh + bl;
+      var i;
+      var v;
+      var f;
+      var n;
+      if (ratio > 1) {
+        wh /= ratio;
+        bl /= ratio;
+      }
+      i = Math.floor(6 * h);
+      v = 1 - bl;
+      f = 6 * h - i;
+      if ((i & 1) !== 0) {
+        f = 1 - f;
+      }
+      n = wh + f * (v - wh);
+      var r;
+      var g;
+      var b;
+      switch (i) {
+        default:
+        case 6:
+        case 0:
+          r = v;
+          g = n;
+          b = wh;
+          break;
+        case 1:
+          r = n;
+          g = v;
+          b = wh;
+          break;
+        case 2:
+          r = wh;
+          g = v;
+          b = n;
+          break;
+        case 3:
+          r = wh;
+          g = n;
+          b = v;
+          break;
+        case 4:
+          r = n;
+          g = wh;
+          b = v;
+          break;
+        case 5:
+          r = v;
+          g = wh;
+          b = n;
+          break;
+      }
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.cmyk.rgb = function(cmyk) {
+      var c = cmyk[0] / 100;
+      var m = cmyk[1] / 100;
+      var y = cmyk[2] / 100;
+      var k = cmyk[3] / 100;
+      var r;
+      var g;
+      var b;
+      r = 1 - Math.min(1, c * (1 - k) + k);
+      g = 1 - Math.min(1, m * (1 - k) + k);
+      b = 1 - Math.min(1, y * (1 - k) + k);
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.xyz.rgb = function(xyz) {
+      var x = xyz[0] / 100;
+      var y = xyz[1] / 100;
+      var z = xyz[2] / 100;
+      var r;
+      var g;
+      var b;
+      r = x * 3.2406 + y * -1.5372 + z * -0.4986;
+      g = x * -0.9689 + y * 1.8758 + z * 0.0415;
+      b = x * 0.0557 + y * -0.204 + z * 1.057;
+      r = r > 31308e-7 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : r * 12.92;
+      g = g > 31308e-7 ? 1.055 * Math.pow(g, 1 / 2.4) - 0.055 : g * 12.92;
+      b = b > 31308e-7 ? 1.055 * Math.pow(b, 1 / 2.4) - 0.055 : b * 12.92;
+      r = Math.min(Math.max(0, r), 1);
+      g = Math.min(Math.max(0, g), 1);
+      b = Math.min(Math.max(0, b), 1);
+      return [r * 255, g * 255, b * 255];
+    };
+    convert.xyz.lab = function(xyz) {
+      var x = xyz[0];
+      var y = xyz[1];
+      var z = xyz[2];
+      var l;
+      var a;
+      var b;
+      x /= 95.047;
+      y /= 100;
+      z /= 108.883;
+      x = x > 8856e-6 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
+      y = y > 8856e-6 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
+      z = z > 8856e-6 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
+      l = 116 * y - 16;
+      a = 500 * (x - y);
+      b = 200 * (y - z);
+      return [l, a, b];
+    };
+    convert.lab.xyz = function(lab) {
+      var l = lab[0];
+      var a = lab[1];
+      var b = lab[2];
+      var x;
+      var y;
+      var z;
+      y = (l + 16) / 116;
+      x = a / 500 + y;
+      z = y - b / 200;
+      var y2 = Math.pow(y, 3);
+      var x2 = Math.pow(x, 3);
+      var z2 = Math.pow(z, 3);
+      y = y2 > 8856e-6 ? y2 : (y - 16 / 116) / 7.787;
+      x = x2 > 8856e-6 ? x2 : (x - 16 / 116) / 7.787;
+      z = z2 > 8856e-6 ? z2 : (z - 16 / 116) / 7.787;
+      x *= 95.047;
+      y *= 100;
+      z *= 108.883;
+      return [x, y, z];
+    };
+    convert.lab.lch = function(lab) {
+      var l = lab[0];
+      var a = lab[1];
+      var b = lab[2];
+      var hr;
+      var h;
+      var c;
+      hr = Math.atan2(b, a);
+      h = hr * 360 / 2 / Math.PI;
+      if (h < 0) {
+        h += 360;
+      }
+      c = Math.sqrt(a * a + b * b);
+      return [l, c, h];
+    };
+    convert.lch.lab = function(lch) {
+      var l = lch[0];
+      var c = lch[1];
+      var h = lch[2];
+      var a;
+      var b;
+      var hr;
+      hr = h / 360 * 2 * Math.PI;
+      a = c * Math.cos(hr);
+      b = c * Math.sin(hr);
+      return [l, a, b];
+    };
+    convert.rgb.ansi16 = function(args) {
+      var r = args[0];
+      var g = args[1];
+      var b = 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 ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+      if (value === 2) {
+        ansi += 60;
+      }
+      return ansi;
+    };
+    convert.hsv.ansi16 = function(args) {
+      return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+    };
+    convert.rgb.ansi256 = function(args) {
+      var r = args[0];
+      var g = args[1];
+      var b = args[2];
+      if (r === g && g === b) {
+        if (r < 8) {
+          return 16;
+        }
+        if (r > 248) {
+          return 231;
+        }
+        return Math.round((r - 8) / 247 * 24) + 232;
+      }
+      var ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+      return ansi;
+    };
+    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 r = (color & 1) * mult * 255;
+      var g = (color >> 1 & 1) * mult * 255;
+      var b = (color >> 2 & 1) * mult * 255;
+      return [r, g, b];
+    };
+    convert.ansi256.rgb = function(args) {
+      if (args >= 232) {
+        var c = (args - 232) * 10 + 8;
+        return [c, c, c];
+      }
+      args -= 16;
+      var rem;
+      var r = Math.floor(args / 36) / 5 * 255;
+      var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+      var b = rem % 6 / 5 * 255;
+      return [r, g, b];
+    };
+    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 r = integer >> 16 & 255;
+      var g = integer >> 8 & 255;
+      var b = integer & 255;
+      return [r, g, b];
+    };
+    convert.rgb.hcg = function(rgb) {
+      var r = rgb[0] / 255;
+      var g = rgb[1] / 255;
+      var b = rgb[2] / 255;
+      var max = Math.max(Math.max(r, g), b);
+      var min = Math.min(Math.min(r, g), b);
+      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 === r) {
+        hue = (g - b) / chroma % 6;
+      } else if (max === g) {
+        hue = 2 + (b - r) / chroma;
+      } else {
+        hue = 4 + (r - g) / chroma + 4;
+      }
+      hue /= 6;
+      hue %= 1;
+      return [hue * 360, chroma * 100, grayscale * 100];
+    };
+    convert.hsl.hcg = function(hsl) {
+      var s = hsl[1] / 100;
+      var l = hsl[2] / 100;
+      var c = 1;
+      var f = 0;
+      if (l < 0.5) {
+        c = 2 * s * l;
+      } else {
+        c = 2 * s * (1 - l);
+      }
+      if (c < 1) {
+        f = (l - 0.5 * c) / (1 - c);
+      }
+      return [hsl[0], c * 100, f * 100];
+    };
+    convert.hsv.hcg = function(hsv) {
+      var s = hsv[1] / 100;
+      var v = hsv[2] / 100;
+      var c = s * v;
+      var f = 0;
+      if (c < 1) {
+        f = (v - c) / (1 - c);
+      }
+      return [hsv[0], c * 100, f * 100];
+    };
+    convert.hcg.rgb = function(hcg) {
+      var h = hcg[0] / 360;
+      var c = hcg[1] / 100;
+      var g = hcg[2] / 100;
+      if (c === 0) {
+        return [g * 255, g * 255, g * 255];
+      }
+      var pure = [0, 0, 0];
+      var hi = h % 1 * 6;
+      var v = hi % 1;
+      var w = 1 - v;
+      var mg = 0;
+      switch (Math.floor(hi)) {
+        case 0:
+          pure[0] = 1;
+          pure[1] = v;
+          pure[2] = 0;
+          break;
+        case 1:
+          pure[0] = w;
+          pure[1] = 1;
+          pure[2] = 0;
+          break;
+        case 2:
+          pure[0] = 0;
+          pure[1] = 1;
+          pure[2] = v;
+          break;
+        case 3:
+          pure[0] = 0;
+          pure[1] = w;
+          pure[2] = 1;
+          break;
+        case 4:
+          pure[0] = v;
+          pure[1] = 0;
+          pure[2] = 1;
+          break;
+        default:
+          pure[0] = 1;
+          pure[1] = 0;
+          pure[2] = w;
+      }
+      mg = (1 - c) * g;
+      return [
+        (c * pure[0] + mg) * 255,
+        (c * pure[1] + mg) * 255,
+        (c * pure[2] + mg) * 255
+      ];
+    };
+    convert.hcg.hsv = function(hcg) {
+      var c = hcg[1] / 100;
+      var g = hcg[2] / 100;
+      var v = c + g * (1 - c);
+      var f = 0;
+      if (v > 0) {
+        f = c / v;
+      }
+      return [hcg[0], f * 100, v * 100];
+    };
+    convert.hcg.hsl = function(hcg) {
+      var c = hcg[1] / 100;
+      var g = hcg[2] / 100;
+      var l = g * (1 - c) + 0.5 * c;
+      var s = 0;
+      if (l > 0 && l < 0.5) {
+        s = c / (2 * l);
+      } else if (l >= 0.5 && l < 1) {
+        s = c / (2 * (1 - l));
+      }
+      return [hcg[0], s * 100, l * 100];
+    };
+    convert.hcg.hwb = function(hcg) {
+      var c = hcg[1] / 100;
+      var g = hcg[2] / 100;
+      var v = c + g * (1 - c);
+      return [hcg[0], (v - c) * 100, (1 - v) * 100];
+    };
+    convert.hwb.hcg = function(hwb) {
+      var w = hwb[1] / 100;
+      var b = hwb[2] / 100;
+      var v = 1 - b;
+      var c = v - w;
+      var g = 0;
+      if (c < 1) {
+        g = (v - c) / (1 - c);
+      }
+      return [hwb[0], c * 100, g * 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(gray) {
+      return [0, 100, gray[0]];
+    };
+    convert.gray.cmyk = function(gray) {
+      return [0, 0, 0, gray[0]];
+    };
+    convert.gray.lab = function(gray) {
+      return [gray[0], 0, 0];
+    };
+    convert.gray.hex = function(gray) {
+      var val = Math.round(gray[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];
+    };
+  }
+});
+var require_route = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/route.js"(exports, module2) {
+    "use strict";
+    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 path5 = [graph[toModel].parent, toModel];
+      var fn = conversions[graph[toModel].parent][toModel];
+      var cur = graph[toModel].parent;
+      while (graph[cur].parent) {
+        path5.unshift(graph[cur].parent);
+        fn = link(conversions[graph[cur].parent][cur], fn);
+        cur = graph[cur].parent;
+      }
+      fn.conversion = path5;
+      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;
+    };
+  }
+});
+var require_color_convert = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/color-convert@1.9.3/node_modules/color-convert/index.js"(exports, module2) {
+    "use strict";
+    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;
+  }
+});
+var require_ansi_styles = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/ansi-styles@3.2.1/node_modules/ansi-styles/index.js"(exports, module2) {
+    "use strict";
+    var colorConvert = require_color_convert();
+    var wrapAnsi16 = (fn, offset) => function() {
+      const code = fn.apply(colorConvert, arguments);
+      return `\x1B[${code + offset}m`;
+    };
+    var wrapAnsi256 = (fn, offset) => function() {
+      const code = fn.apply(colorConvert, arguments);
+      return `\x1B[${38 + offset};5;${code}m`;
+    };
+    var wrapAnsi16m = (fn, offset) => function() {
+      const rgb = fn.apply(colorConvert, arguments);
+      return `\x1B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`;
+    };
+    function assembleStyles() {
+      const codes = /* @__PURE__ */ new Map();
+      const 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],
+          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]
+        }
+      };
+      styles.color.grey = styles.color.gray;
+      for (const groupName of Object.keys(styles)) {
+        const group = styles[groupName];
+        for (const styleName of Object.keys(group)) {
+          const style = group[styleName];
+          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
+        });
+      }
+      const ansi2ansi = (n) => n;
+      const rgb2rgb = (r, g, b) => [r, g, b];
+      styles.color.close = "\x1B[39m";
+      styles.bgColor.close = "\x1B[49m";
+      styles.color.ansi = {
+        ansi: wrapAnsi16(ansi2ansi, 0)
+      };
+      styles.color.ansi256 = {
+        ansi256: wrapAnsi256(ansi2ansi, 0)
+      };
+      styles.color.ansi16m = {
+        rgb: wrapAnsi16m(rgb2rgb, 0)
+      };
+      styles.bgColor.ansi = {
+        ansi: wrapAnsi16(ansi2ansi, 10)
+      };
+      styles.bgColor.ansi256 = {
+        ansi256: wrapAnsi256(ansi2ansi, 10)
+      };
+      styles.bgColor.ansi16m = {
+        rgb: wrapAnsi16m(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) {
+          styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
+          styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
+        }
+        if ("ansi256" in suite) {
+          styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
+          styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
+        }
+        if ("rgb" in suite) {
+          styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
+          styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
+        }
+      }
+      return styles;
+    }
+    Object.defineProperty(module2, "exports", {
+      enumerable: true,
+      get: assembleStyles
+    });
+  }
+});
+var require_has_flag = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/has-flag@3.0.0/node_modules/has-flag/index.js"(exports, 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);
+    };
+  }
+});
+var require_supports_color = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/supports-color@5.5.0/node_modules/supports-color/index.js"(exports, module2) {
+    "use strict";
+    var os = (0, import_chunk_4VNS5WPM.__require)("os");
+    var hasFlag = require_has_flag();
+    var env = 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 env) {
+      forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
       return {
-        keyword: colors.cyan,
-        capitalized: colors.yellow,
-        jsxIdentifier: colors.yellow,
-        punctuator: colors.yellow,
-        number: colors.magenta,
-        string: colors.green,
-        regex: colors.magenta,
-        comment: colors.gray,
-        invalid: compose(compose(colors.white, colors.bgRed), colors.bold),
-        gutter: colors.gray,
-        marker: compose(colors.red, colors.bold),
-        message: compose(colors.red, colors.bold),
-        reset: colors.reset
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
       };
     }
-    var defsOn = buildDefs(picocolors.createColors(true));
-    var defsOff = buildDefs(picocolors.createColors(false));
-    function getDefs(enabled) {
-      return enabled ? defsOn : defsOff;
+    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 env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].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 ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 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;
+      }
+      if (env.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)
+    };
+  }
+});
+var require_templates = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/templates.js"(exports, 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 ESCAPES = /* @__PURE__ */ new Map([
+      ["n", "\n"],
+      ["r", "\r"],
+      ["t", "	"],
+      ["b", "\b"],
+      ["f", "\f"],
+      ["v", "\v"],
+      ["0", "\0"],
+      ["\\", "\\"],
+      ["e", "\x1B"],
+      ["a", "\x07"]
+    ]);
+    function unescape(c) {
+      if (c[0] === "u" && c.length === 5 || c[0] === "x" && c.length === 3) {
+        return String.fromCharCode(parseInt(c.slice(1), 16));
+      }
+      return ESCAPES.get(c) || c;
+    }
+    function parseArguments(name, 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, (m, escape, chr) => escape ? unescape(escape) : chr));
+        } else {
+          throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
+        }
+      }
+      return results;
+    }
+    function parseStyle(style) {
+      STYLE_REGEX.lastIndex = 0;
+      const results = [];
+      let matches;
+      while ((matches = STYLE_REGEX.exec(style)) !== null) {
+        const name = matches[1];
+        if (matches[2]) {
+          const args = parseArguments(name, matches[2]);
+          results.push([name].concat(args));
+        } else {
+          results.push([name]);
+        }
+      }
+      return results;
+    }
+    function buildStyle(chalk, styles) {
+      const enabled = {};
+      for (const layer of styles) {
+        for (const style of layer.styles) {
+          enabled[style[0]] = layer.inverse ? null : style.slice(1);
+        }
+      }
+      let current = chalk;
+      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 = (chalk, tmp) => {
+      const styles = [];
+      const chunks = [];
+      let chunk = [];
+      tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
+        if (escapeChar) {
+          chunk.push(unescape(escapeChar));
+        } else if (style) {
+          const str = chunk.join("");
+          chunk = [];
+          chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+          styles.push({ inverse, styles: parseStyle(style) });
+        } else if (close) {
+          if (styles.length === 0) {
+            throw new Error("Found extraneous } in Chalk template literal");
+          }
+          chunks.push(buildStyle(chalk, styles)(chunk.join("")));
+          chunk = [];
+          styles.pop();
+        } else {
+          chunk.push(chr);
+        }
+      });
+      chunks.push(chunk.join(""));
+      if (styles.length > 0) {
+        const errMsg = `Chalk template literal is missing ${styles.length} closing bracket${styles.length === 1 ? "" : "s"} (\`}\`)`;
+        throw new Error(errMsg);
+      }
+      return chunks.join("");
+    };
+  }
+});
+var require_chalk = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/chalk@2.4.2/node_modules/chalk/index.js"(exports, module2) {
+    "use strict";
+    var escapeStringRegexp = require_escape_string_regexp();
+    var ansiStyles = 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 styles = /* @__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 chalk = {};
+        applyOptions(chalk, options);
+        chalk.template = function() {
+          const args = [].slice.call(arguments);
+          return chalkTag.apply(null, [chalk.template].concat(args));
+        };
+        Object.setPrototypeOf(chalk, Chalk.prototype);
+        Object.setPrototypeOf(chalk.template, chalk);
+        chalk.template.constructor = Chalk;
+        return chalk.template;
+      }
+      applyOptions(this, options);
+    }
+    if (isSimpleWindowsTerm) {
+      ansiStyles.blue.open = "\x1B[94m";
+    }
+    for (const key of Object.keys(ansiStyles)) {
+      ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), "g");
+      styles[key] = {
+        get() {
+          const codes = ansiStyles[key];
+          return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+        }
+      };
+    }
+    styles.visible = {
+      get() {
+        return build.call(this, this._styles || [], true, "visible");
+      }
+    };
+    ansiStyles.color.closeRe = new RegExp(escapeStringRegexp(ansiStyles.color.close), "g");
+    for (const model of Object.keys(ansiStyles.color.ansi)) {
+      if (skipModels.has(model)) {
+        continue;
+      }
+      styles[model] = {
+        get() {
+          const level = this.level;
+          return function() {
+            const open = ansiStyles.color[levelMapping[level]][model].apply(null, arguments);
+            const codes = {
+              open,
+              close: ansiStyles.color.close,
+              closeRe: ansiStyles.color.closeRe
+            };
+            return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+          };
+        }
+      };
+    }
+    ansiStyles.bgColor.closeRe = new RegExp(escapeStringRegexp(ansiStyles.bgColor.close), "g");
+    for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
+      if (skipModels.has(model)) {
+        continue;
+      }
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles[bgModel] = {
+        get() {
+          const level = this.level;
+          return function() {
+            const open = ansiStyles.bgColor[levelMapping[level]][model].apply(null, arguments);
+            const codes = {
+              open,
+              close: ansiStyles.bgColor.close,
+              closeRe: ansiStyles.bgColor.closeRe
+            };
+            return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+          };
+        }
+      };
+    }
+    var proto = Object.defineProperties(() => {
+    }, styles);
+    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 = ansiStyles.dim.open;
+      if (isSimpleWindowsTerm && this.hasGrey) {
+        ansiStyles.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}`);
+      }
+      ansiStyles.dim.open = originalDim;
+      return str;
+    }
+    function chalkTag(chalk, 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(chalk, parts.join(""));
+    }
+    Object.defineProperties(Chalk.prototype, styles);
+    module2.exports = Chalk();
+    module2.exports.supportsColor = stdoutColor;
+    module2.exports.default = module2.exports;
+  }
+});
+var require_lib6 = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/@babel+highlight@7.23.4/node_modules/@babel/highlight/lib/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = highlight;
+    exports.shouldHighlight = shouldHighlight;
+    var _jsTokens = require_js_tokens();
+    var _helperValidatorIdentifier = (0, import_chunk_UZTXEBTM.require_lib)();
+    var _chalk = _interopRequireWildcard(require_chalk(), true);
+    function _getRequireWildcardCache(e) {
+      if ("function" != typeof WeakMap) return null;
+      var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(e2) {
+        return e2 ? t : r;
+      })(e);
+    }
+    function _interopRequireWildcard(e, r) {
+      if (!r && e && e.__esModule) return e;
+      if (null === e || "object" != typeof e && "function" != typeof e) return { default: e };
+      var t = _getRequireWildcardCache(r);
+      if (t && t.has(e)) return t.get(e);
+      var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) {
+        var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
+        i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
+      }
+      return n.default = e, t && t.set(e, n), n;
     }
     var sometimesKeywords = /* @__PURE__ */ new Set(["as", "async", "from", "get", "of", "set"]);
-    var NEWLINE$1 = /\r\n|[\n\r\u2028\u2029]/;
+    function getDefs(chalk) {
+      return {
+        keyword: chalk.cyan,
+        capitalized: chalk.yellow,
+        jsxIdentifier: chalk.yellow,
+        punctuator: chalk.yellow,
+        number: chalk.magenta,
+        string: chalk.green,
+        regex: chalk.magenta,
+        comment: chalk.grey,
+        invalid: chalk.white.bgRed.bold
+      };
+    }
+    var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
     var BRACKET = /^[()[\]{}]$/;
     var tokenize;
     {
       const JSX_TAG = /^[a-z][\w-]*$/i;
       const getTokenType = function(token, offset, text) {
         if (token.type === "name") {
-          if (helperValidatorIdentifier.isKeyword(token.value) || helperValidatorIdentifier.isStrictReservedWord(token.value, true) || sometimesKeywords.has(token.value)) {
+          if ((0, _helperValidatorIdentifier.isKeyword)(token.value) || (0, _helperValidatorIdentifier.isStrictReservedWord)(token.value, true) || sometimesKeywords.has(token.value)) {
             return "keyword";
           }
-          if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) === "</")) {
+          if (JSX_TAG.test(token.value) && (text[offset - 1] === "<" || text.slice(offset - 2, offset) == "</")) {
             return "jsxIdentifier";
           }
           if (token.value[0] !== token.value[0].toLowerCase()) {
@@ -3319,8 +4783,8 @@ var require_lib6 = (0, import_chunk_4VNS5WPM.__commonJS)({
       };
       tokenize = function* (text) {
         let match;
-        while (match = jsTokens.default.exec(text)) {
-          const token = jsTokens.matchToToken(match);
+        while (match = _jsTokens.default.exec(text)) {
+          const token = _jsTokens.matchToToken(match);
           yield {
             type: getTokenType(token, match.index, text),
             value: token.value
@@ -3328,23 +4792,98 @@ var require_lib6 = (0, import_chunk_4VNS5WPM.__commonJS)({
         }
       };
     }
-    function highlight(text) {
-      if (text === "") return "";
-      const defs = getDefs(true);
+    function highlightTokens(defs, text) {
       let highlighted = "";
       for (const {
         type,
         value
       } of tokenize(text)) {
-        if (type in defs) {
-          highlighted += value.split(NEWLINE$1).map((str) => defs[type](str)).join("\n");
+        const colorize = defs[type];
+        if (colorize) {
+          highlighted += value.split(NEWLINE).map((str) => colorize(str)).join("\n");
         } else {
           highlighted += value;
         }
       }
       return highlighted;
     }
+    function shouldHighlight(options) {
+      return _chalk.default.level > 0 || options.forceColor;
+    }
+    var chalkWithForcedColor = void 0;
+    function getChalk(forceColor) {
+      if (forceColor) {
+        var _chalkWithForcedColor;
+        (_chalkWithForcedColor = chalkWithForcedColor) != null ? _chalkWithForcedColor : chalkWithForcedColor = new _chalk.default.constructor({
+          enabled: true,
+          level: 1
+        });
+        return chalkWithForcedColor;
+      }
+      return _chalk.default;
+    }
+    {
+      exports.getChalk = (options) => getChalk(options.forceColor);
+    }
+    function highlight(code, options = {}) {
+      if (code !== "" && shouldHighlight(options)) {
+        const defs = getDefs(getChalk(options.forceColor));
+        return highlightTokens(defs, code);
+      } else {
+        return code;
+      }
+    }
+  }
+});
+var require_lib7 = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/@babel+code-frame@7.23.5/node_modules/@babel/code-frame/lib/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.codeFrameColumns = codeFrameColumns2;
+    exports.default = _default;
+    var _highlight = require_lib6();
+    var _chalk = _interopRequireWildcard(require_chalk(), true);
+    function _getRequireWildcardCache(e) {
+      if ("function" != typeof WeakMap) return null;
+      var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(e2) {
+        return e2 ? t : r;
+      })(e);
+    }
+    function _interopRequireWildcard(e, r) {
+      if (!r && e && e.__esModule) return e;
+      if (null === e || "object" != typeof e && "function" != typeof e) return { default: e };
+      var t = _getRequireWildcardCache(r);
+      if (t && t.has(e)) return t.get(e);
+      var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) {
+        var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
+        i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
+      }
+      return n.default = e, t && t.set(e, n), n;
+    }
+    var chalkWithForcedColor = void 0;
+    function getChalk(forceColor) {
+      if (forceColor) {
+        var _chalkWithForcedColor;
+        (_chalkWithForcedColor = chalkWithForcedColor) != null ? _chalkWithForcedColor : chalkWithForcedColor = new _chalk.default.constructor({
+          enabled: true,
+          level: 1
+        });
+        return chalkWithForcedColor;
+      }
+      return _chalk.default;
+    }
     var deprecationWarningShown = false;
+    function getDefs(chalk) {
+      return {
+        gutter: chalk.grey,
+        marker: chalk.red.bold,
+        message: chalk.red.bold
+      };
+    }
     var NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
     function getMarkerLines(loc, source, opts) {
       const startLoc = Object.assign({
@@ -3403,8 +4942,12 @@ var require_lib6 = (0, import_chunk_4VNS5WPM.__commonJS)({
       };
     }
     function codeFrameColumns2(rawLines, loc, opts = {}) {
-      const shouldHighlight = opts.forceColor || isColorSupported() && opts.highlightCode;
-      const defs = getDefs(shouldHighlight);
+      const highlighted = (opts.highlightCode || opts.forceColor) && (0, _highlight.shouldHighlight)(opts);
+      const chalk = getChalk(opts.forceColor);
+      const defs = getDefs(chalk);
+      const maybeHighlight = (chalkFn, string) => {
+        return highlighted ? chalkFn(string) : string;
+      };
       const lines = rawLines.split(NEWLINE);
       const {
         start,
@@ -3413,9 +4956,9 @@ var require_lib6 = (0, import_chunk_4VNS5WPM.__commonJS)({
       } = getMarkerLines(loc, lines, opts);
       const hasColumns = loc.start && typeof loc.start.column === "number";
       const numberMaxWidth = String(end).length;
-      const highlightedLines = shouldHighlight ? highlight(rawLines) : rawLines;
-      let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index2) => {
-        const number = start + 1 + index2;
+      const highlightedLines = highlighted ? (0, _highlight.default)(rawLines, opts) : rawLines;
+      let frame = highlightedLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
+        const number = start + 1 + index;
         const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
         const gutter = ` ${paddedNumber} |`;
         const hasMarker = markerLines[number];
@@ -3425,27 +4968,27 @@ var require_lib6 = (0, import_chunk_4VNS5WPM.__commonJS)({
           if (Array.isArray(hasMarker)) {
             const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
             const numberOfMarkers = hasMarker[1] || 1;
-            markerLine = ["\n ", defs.gutter(gutter.replace(/\d/g, " ")), " ", markerSpacing, defs.marker("^").repeat(numberOfMarkers)].join("");
+            markerLine = ["\n ", maybeHighlight(defs.gutter, gutter.replace(/\d/g, " ")), " ", markerSpacing, maybeHighlight(defs.marker, "^").repeat(numberOfMarkers)].join("");
             if (lastMarkerLine && opts.message) {
-              markerLine += " " + defs.message(opts.message);
+              markerLine += " " + maybeHighlight(defs.message, opts.message);
             }
           }
-          return [defs.marker(">"), defs.gutter(gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
+          return [maybeHighlight(defs.marker, ">"), maybeHighlight(defs.gutter, gutter), line.length > 0 ? ` ${line}` : "", markerLine].join("");
         } else {
-          return ` ${defs.gutter(gutter)}${line.length > 0 ? ` ${line}` : ""}`;
+          return ` ${maybeHighlight(defs.gutter, gutter)}${line.length > 0 ? ` ${line}` : ""}`;
         }
       }).join("\n");
       if (opts.message && !hasColumns) {
         frame = `${" ".repeat(numberMaxWidth + 1)}${opts.message}
 ${frame}`;
       }
-      if (shouldHighlight) {
-        return defs.reset(frame);
+      if (highlighted) {
+        return chalk.reset(frame);
       } else {
         return frame;
       }
     }
-    function index(rawLines, lineNumber, colNumber, opts = {}) {
+    function _default(rawLines, lineNumber, colNumber, opts = {}) {
       if (!deprecationWarningShown) {
         deprecationWarningShown = true;
         const message = "Passing lineNumber and colNumber is deprecated to @babel/code-frame. Please use `codeFrameColumns`.";
@@ -3466,9 +5009,6 @@ ${frame}`;
       };
       return codeFrameColumns2(rawLines, location, opts);
     }
-    exports.codeFrameColumns = codeFrameColumns2;
-    exports.default = index;
-    exports.highlight = highlight;
   }
 });
 var require_debug = (0, import_chunk_4VNS5WPM.__commonJS)({
@@ -4882,7 +6422,7 @@ var require_spdx_expression_parse = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_spdx_correct = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/spdx-correct@3.2.0/node_modules/spdx-correct/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/spdx-correct@3.1.1/node_modules/spdx-correct/index.js"(exports, module2) {
     "use strict";
     var parse = require_spdx_expression_parse();
     var spdxLicenseIds = require_spdx_license_ids();
@@ -4894,11 +6434,6 @@ var require_spdx_correct = (0, import_chunk_4VNS5WPM.__commonJS)({
         return false;
       }
     }
-    function sortTranspositions(a, b) {
-      var length = b[0].length - a[0].length;
-      if (length !== 0) return length;
-      return a[0].toUpperCase().localeCompare(b[0].toUpperCase());
-    }
     var transpositions = [
       ["APGL", "AGPL"],
       ["Gpl", "GPL"],
@@ -4914,17 +6449,8 @@ var require_spdx_correct = (0, import_chunk_4VNS5WPM.__commonJS)({
       ["GUN", "GPL"],
       ["+", ""],
       ["GNU GPL", "GPL"],
-      ["GNU LGPL", "LGPL"],
       ["GNU/GPL", "GPL"],
       ["GNU GLP", "GPL"],
-      ["GNU LESSER GENERAL PUBLIC LICENSE", "LGPL"],
-      ["GNU Lesser General Public License", "LGPL"],
-      ["GNU LESSER GENERAL PUBLIC LICENSE", "LGPL-2.1"],
-      ["GNU Lesser General Public License", "LGPL-2.1"],
-      ["LESSER GENERAL PUBLIC LICENSE", "LGPL"],
-      ["Lesser General Public License", "LGPL"],
-      ["LESSER GENERAL PUBLIC LICENSE", "LGPL-2.1"],
-      ["Lesser General Public License", "LGPL-2.1"],
       ["GNU General Public License", "GPL"],
       ["Gnu public license", "GPL"],
       ["GNU Public License", "GPL"],
@@ -4933,9 +6459,8 @@ var require_spdx_correct = (0, import_chunk_4VNS5WPM.__commonJS)({
       ["Mozilla Public License", "MPL"],
       ["Universal Permissive License", "UPL"],
       ["WTH", "WTF"],
-      ["WTFGPL", "WTFPL"],
       ["-License", ""]
-    ].sort(sortTranspositions);
+    ];
     var TRANSPOSED = 0;
     var CORRECT = 1;
     var transforms = [
@@ -5103,7 +6628,7 @@ var require_spdx_correct = (0, import_chunk_4VNS5WPM.__commonJS)({
       ["MPL", "MPL-2.0"],
       ["X11", "X11"],
       ["ZLIB", "Zlib"]
-    ].concat(licensesWithOneVersion).sort(sortTranspositions);
+    ].concat(licensesWithOneVersion);
     var SUBSTRING = 0;
     var IDENTIFIER = 1;
     var validTransformation = function(identifier) {
@@ -6659,7 +8184,7 @@ var require_commonjs = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_hosts = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/hosted-git-info@7.0.2/node_modules/hosted-git-info/lib/hosts.js"(exports, module2) {
+  "../../node_modules/.pnpm/hosted-git-info@7.0.1/node_modules/hosted-git-info/lib/hosts.js"(exports, module2) {
     "use strict";
     var maybeJoin = (...args) => args.every((arg) => arg) ? args.join("") : "";
     var maybeEncode = (arg) => arg ? encodeURIComponent(arg) : "";
@@ -6802,7 +8327,7 @@ var require_hosts = (0, import_chunk_4VNS5WPM.__commonJS)({
       filetemplate: ({ domain, user, project, committish, path: path5 }) => `https://${domain}/${user}/${project}/blob/${maybeEncode(committish) || "HEAD"}/${path5}`,
       httpstemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}.git${maybeJoin("#", committish)}`,
       tarballtemplate: ({ domain, user, project, committish }) => `https://${domain}/${user}/${project}/archive/${maybeEncode(committish) || "HEAD"}.tar.gz`,
-      bugstemplate: () => null,
+      bugstemplate: ({ user, project }) => null,
       extract: (url) => {
         let [, user, project, aux] = url.pathname.split("/", 4);
         if (["archive"].includes(aux)) {
@@ -6824,7 +8349,7 @@ var require_hosts = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_parse_url = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/hosted-git-info@7.0.2/node_modules/hosted-git-info/lib/parse-url.js"(exports, module2) {
+  "../../node_modules/.pnpm/hosted-git-info@7.0.1/node_modules/hosted-git-info/lib/parse-url.js"(exports, module2) {
     "use strict";
     var url = (0, import_chunk_4VNS5WPM.__require)("url");
     var lastIndexOfBefore = (str, char, beforeChar) => {
@@ -6875,7 +8400,7 @@ var require_parse_url = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_from_url = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/hosted-git-info@7.0.2/node_modules/hosted-git-info/lib/from-url.js"(exports, module2) {
+  "../../node_modules/.pnpm/hosted-git-info@7.0.1/node_modules/hosted-git-info/lib/from-url.js"(exports, module2) {
     "use strict";
     var parseUrl = require_parse_url();
     var isGitHubShorthand = (arg) => {
@@ -6966,8 +8491,8 @@ var require_from_url = (0, import_chunk_4VNS5WPM.__commonJS)({
     };
   }
 });
-var require_lib7 = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/hosted-git-info@7.0.2/node_modules/hosted-git-info/lib/index.js"(exports, module2) {
+var require_lib8 = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/hosted-git-info@7.0.1/node_modules/hosted-git-info/lib/index.js"(exports, module2) {
     "use strict";
     var { LRUCache } = require_commonjs();
     var hosts = require_hosts();
@@ -7108,8 +8633,240 @@ var require_lib7 = (0, import_chunk_4VNS5WPM.__commonJS)({
     module2.exports = GitHost;
   }
 });
+var require_hasown = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/hasown@2.0.0/node_modules/hasown/index.js"(exports, module2) {
+    "use strict";
+    var call = Function.prototype.call;
+    var $hasOwn = Object.prototype.hasOwnProperty;
+    var bind = (0, import_chunk_VVPSLVOR.require_function_bind)();
+    module2.exports = bind.call(call, $hasOwn);
+  }
+});
+var require_core = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/is-core-module@2.13.1/node_modules/is-core-module/core.json"(exports, module2) {
+    module2.exports = {
+      assert: true,
+      "node:assert": [">= 14.18 && < 15", ">= 16"],
+      "assert/strict": ">= 15",
+      "node:assert/strict": ">= 16",
+      async_hooks: ">= 8",
+      "node:async_hooks": [">= 14.18 && < 15", ">= 16"],
+      buffer_ieee754: ">= 0.5 && < 0.9.7",
+      buffer: true,
+      "node:buffer": [">= 14.18 && < 15", ">= 16"],
+      child_process: true,
+      "node:child_process": [">= 14.18 && < 15", ">= 16"],
+      cluster: ">= 0.5",
+      "node:cluster": [">= 14.18 && < 15", ">= 16"],
+      console: true,
+      "node:console": [">= 14.18 && < 15", ">= 16"],
+      constants: true,
+      "node:constants": [">= 14.18 && < 15", ">= 16"],
+      crypto: true,
+      "node:crypto": [">= 14.18 && < 15", ">= 16"],
+      _debug_agent: ">= 1 && < 8",
+      _debugger: "< 8",
+      dgram: true,
+      "node:dgram": [">= 14.18 && < 15", ">= 16"],
+      diagnostics_channel: [">= 14.17 && < 15", ">= 15.1"],
+      "node:diagnostics_channel": [">= 14.18 && < 15", ">= 16"],
+      dns: true,
+      "node:dns": [">= 14.18 && < 15", ">= 16"],
+      "dns/promises": ">= 15",
+      "node:dns/promises": ">= 16",
+      domain: ">= 0.7.12",
+      "node:domain": [">= 14.18 && < 15", ">= 16"],
+      events: true,
+      "node:events": [">= 14.18 && < 15", ">= 16"],
+      freelist: "< 6",
+      fs: true,
+      "node:fs": [">= 14.18 && < 15", ">= 16"],
+      "fs/promises": [">= 10 && < 10.1", ">= 14"],
+      "node:fs/promises": [">= 14.18 && < 15", ">= 16"],
+      _http_agent: ">= 0.11.1",
+      "node:_http_agent": [">= 14.18 && < 15", ">= 16"],
+      _http_client: ">= 0.11.1",
+      "node:_http_client": [">= 14.18 && < 15", ">= 16"],
+      _http_common: ">= 0.11.1",
+      "node:_http_common": [">= 14.18 && < 15", ">= 16"],
+      _http_incoming: ">= 0.11.1",
+      "node:_http_incoming": [">= 14.18 && < 15", ">= 16"],
+      _http_outgoing: ">= 0.11.1",
+      "node:_http_outgoing": [">= 14.18 && < 15", ">= 16"],
+      _http_server: ">= 0.11.1",
+      "node:_http_server": [">= 14.18 && < 15", ">= 16"],
+      http: true,
+      "node:http": [">= 14.18 && < 15", ">= 16"],
+      http2: ">= 8.8",
+      "node:http2": [">= 14.18 && < 15", ">= 16"],
+      https: true,
+      "node:https": [">= 14.18 && < 15", ">= 16"],
+      inspector: ">= 8",
+      "node:inspector": [">= 14.18 && < 15", ">= 16"],
+      "inspector/promises": [">= 19"],
+      "node:inspector/promises": [">= 19"],
+      _linklist: "< 8",
+      module: true,
+      "node:module": [">= 14.18 && < 15", ">= 16"],
+      net: true,
+      "node:net": [">= 14.18 && < 15", ">= 16"],
+      "node-inspect/lib/_inspect": ">= 7.6 && < 12",
+      "node-inspect/lib/internal/inspect_client": ">= 7.6 && < 12",
+      "node-inspect/lib/internal/inspect_repl": ">= 7.6 && < 12",
+      os: true,
+      "node:os": [">= 14.18 && < 15", ">= 16"],
+      path: true,
+      "node:path": [">= 14.18 && < 15", ">= 16"],
+      "path/posix": ">= 15.3",
+      "node:path/posix": ">= 16",
+      "path/win32": ">= 15.3",
+      "node:path/win32": ">= 16",
+      perf_hooks: ">= 8.5",
+      "node:perf_hooks": [">= 14.18 && < 15", ">= 16"],
+      process: ">= 1",
+      "node:process": [">= 14.18 && < 15", ">= 16"],
+      punycode: ">= 0.5",
+      "node:punycode": [">= 14.18 && < 15", ">= 16"],
+      querystring: true,
+      "node:querystring": [">= 14.18 && < 15", ">= 16"],
+      readline: true,
+      "node:readline": [">= 14.18 && < 15", ">= 16"],
+      "readline/promises": ">= 17",
+      "node:readline/promises": ">= 17",
+      repl: true,
+      "node:repl": [">= 14.18 && < 15", ">= 16"],
+      smalloc: ">= 0.11.5 && < 3",
+      _stream_duplex: ">= 0.9.4",
+      "node:_stream_duplex": [">= 14.18 && < 15", ">= 16"],
+      _stream_transform: ">= 0.9.4",
+      "node:_stream_transform": [">= 14.18 && < 15", ">= 16"],
+      _stream_wrap: ">= 1.4.1",
+      "node:_stream_wrap": [">= 14.18 && < 15", ">= 16"],
+      _stream_passthrough: ">= 0.9.4",
+      "node:_stream_passthrough": [">= 14.18 && < 15", ">= 16"],
+      _stream_readable: ">= 0.9.4",
+      "node:_stream_readable": [">= 14.18 && < 15", ">= 16"],
+      _stream_writable: ">= 0.9.4",
+      "node:_stream_writable": [">= 14.18 && < 15", ">= 16"],
+      stream: true,
+      "node:stream": [">= 14.18 && < 15", ">= 16"],
+      "stream/consumers": ">= 16.7",
+      "node:stream/consumers": ">= 16.7",
+      "stream/promises": ">= 15",
+      "node:stream/promises": ">= 16",
+      "stream/web": ">= 16.5",
+      "node:stream/web": ">= 16.5",
+      string_decoder: true,
+      "node:string_decoder": [">= 14.18 && < 15", ">= 16"],
+      sys: [">= 0.4 && < 0.7", ">= 0.8"],
+      "node:sys": [">= 14.18 && < 15", ">= 16"],
+      "test/reporters": ">= 19.9 && < 20.2",
+      "node:test/reporters": [">= 18.17 && < 19", ">= 19.9", ">= 20"],
+      "node:test": [">= 16.17 && < 17", ">= 18"],
+      timers: true,
+      "node:timers": [">= 14.18 && < 15", ">= 16"],
+      "timers/promises": ">= 15",
+      "node:timers/promises": ">= 16",
+      _tls_common: ">= 0.11.13",
+      "node:_tls_common": [">= 14.18 && < 15", ">= 16"],
+      _tls_legacy: ">= 0.11.3 && < 10",
+      _tls_wrap: ">= 0.11.3",
+      "node:_tls_wrap": [">= 14.18 && < 15", ">= 16"],
+      tls: true,
+      "node:tls": [">= 14.18 && < 15", ">= 16"],
+      trace_events: ">= 10",
+      "node:trace_events": [">= 14.18 && < 15", ">= 16"],
+      tty: true,
+      "node:tty": [">= 14.18 && < 15", ">= 16"],
+      url: true,
+      "node:url": [">= 14.18 && < 15", ">= 16"],
+      util: true,
+      "node:util": [">= 14.18 && < 15", ">= 16"],
+      "util/types": ">= 15.3",
+      "node:util/types": ">= 16",
+      "v8/tools/arguments": ">= 10 && < 12",
+      "v8/tools/codemap": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/consarray": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/csvparser": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/logreader": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/profile_view": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      "v8/tools/splaytree": [">= 4.4 && < 5", ">= 5.2 && < 12"],
+      v8: ">= 1",
+      "node:v8": [">= 14.18 && < 15", ">= 16"],
+      vm: true,
+      "node:vm": [">= 14.18 && < 15", ">= 16"],
+      wasi: [">= 13.4 && < 13.5", ">= 18.17 && < 19", ">= 20"],
+      "node:wasi": [">= 18.17 && < 19", ">= 20"],
+      worker_threads: ">= 11.7",
+      "node:worker_threads": [">= 14.18 && < 15", ">= 16"],
+      zlib: ">= 0.5",
+      "node:zlib": [">= 14.18 && < 15", ">= 16"]
+    };
+  }
+});
+var require_is_core_module = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/is-core-module@2.13.1/node_modules/is-core-module/index.js"(exports, module2) {
+    "use strict";
+    var hasOwn = require_hasown();
+    function specifierIncluded(current, specifier) {
+      var nodeParts = current.split(".");
+      var parts = specifier.split(" ");
+      var op = parts.length > 1 ? parts[0] : "=";
+      var versionParts = (parts.length > 1 ? parts[1] : parts[0]).split(".");
+      for (var i = 0; i < 3; ++i) {
+        var cur = parseInt(nodeParts[i] || 0, 10);
+        var ver = parseInt(versionParts[i] || 0, 10);
+        if (cur === ver) {
+          continue;
+        }
+        if (op === "<") {
+          return cur < ver;
+        }
+        if (op === ">=") {
+          return cur >= ver;
+        }
+        return false;
+      }
+      return op === ">=";
+    }
+    function matchesRange(current, range) {
+      var specifiers = range.split(/ ?&& ?/);
+      if (specifiers.length === 0) {
+        return false;
+      }
+      for (var i = 0; i < specifiers.length; ++i) {
+        if (!specifierIncluded(current, specifiers[i])) {
+          return false;
+        }
+      }
+      return true;
+    }
+    function versionIncluded(nodeVersion, specifierValue) {
+      if (typeof specifierValue === "boolean") {
+        return specifierValue;
+      }
+      var current = typeof nodeVersion === "undefined" ? process.versions && process.versions.node : nodeVersion;
+      if (typeof current !== "string") {
+        throw new TypeError(typeof nodeVersion === "undefined" ? "Unable to determine current node version" : "If provided, a valid node version is required");
+      }
+      if (specifierValue && typeof specifierValue === "object") {
+        for (var i = 0; i < specifierValue.length; ++i) {
+          if (matchesRange(current, specifierValue[i])) {
+            return true;
+          }
+        }
+        return false;
+      }
+      return matchesRange(current, specifierValue);
+    }
+    var data = require_core();
+    module2.exports = function isCore(x, nodeVersion) {
+      return hasOwn(data, x) && versionIncluded(nodeVersion, data[x]);
+    };
+  }
+});
 var require_extract_description = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/normalize-package-data@6.0.2/node_modules/normalize-package-data/lib/extract_description.js"(exports, module2) {
+  "../../node_modules/.pnpm/normalize-package-data@6.0.0/node_modules/normalize-package-data/lib/extract_description.js"(exports, module2) {
     "use strict";
     module2.exports = extractDescription;
     function extractDescription(d) {
@@ -7134,7 +8891,7 @@ var require_extract_description = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_typos = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/normalize-package-data@6.0.2/node_modules/normalize-package-data/lib/typos.json"(exports, module2) {
+  "../../node_modules/.pnpm/normalize-package-data@6.0.0/node_modules/normalize-package-data/lib/typos.json"(exports, module2) {
     module2.exports = {
       topLevel: {
         dependancies: "dependencies",
@@ -7163,13 +8920,13 @@ var require_typos = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_fixer = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/normalize-package-data@6.0.2/node_modules/normalize-package-data/lib/fixer.js"(exports, module2) {
+  "../../node_modules/.pnpm/normalize-package-data@6.0.0/node_modules/normalize-package-data/lib/fixer.js"(exports, module2) {
     "use strict";
     var isValidSemver = require_valid();
     var cleanSemver = require_clean();
     var validateLicense = require_validate_npm_package_license();
-    var hostedGitInfo = require_lib7();
-    var moduleBuiltin = (0, import_chunk_4VNS5WPM.__require)("node:module");
+    var hostedGitInfo = require_lib8();
+    var isBuiltinModule = require_is_core_module();
     var depTypes = ["dependencies", "devDependencies", "optionalDependencies"];
     var extractDescription = require_extract_description();
     var url = (0, import_chunk_4VNS5WPM.__require)("url");
@@ -7296,7 +9053,7 @@ var require_fixer = (0, import_chunk_4VNS5WPM.__commonJS)({
           }, this);
         }
       },
-      fixDependencies: function(data) {
+      fixDependencies: function(data, strict) {
         objectifyDeps(data, this.warn);
         addOptionalDepsToDeps(data, this.warn);
         this.fixBundleDependenciesField(data);
@@ -7380,7 +9137,7 @@ var require_fixer = (0, import_chunk_4VNS5WPM.__commonJS)({
           data.name = data.name.trim();
         }
         ensureValidName(data.name, strict, options.allowLegacyCase);
-        if (moduleBuiltin.builtinModules.includes(data.name)) {
+        if (isBuiltinModule(data.name)) {
           this.warn("conflictingName", data.name);
         }
       },
@@ -7536,7 +9293,7 @@ var require_fixer = (0, import_chunk_4VNS5WPM.__commonJS)({
       }
       return obj;
     }
-    function addOptionalDepsToDeps(data) {
+    function addOptionalDepsToDeps(data, warn) {
       var o = data.optionalDependencies;
       if (!o) {
         return;
@@ -7594,7 +9351,7 @@ var require_fixer = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_warning_messages = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/normalize-package-data@6.0.2/node_modules/normalize-package-data/lib/warning_messages.json"(exports, module2) {
+  "../../node_modules/.pnpm/normalize-package-data@6.0.0/node_modules/normalize-package-data/lib/warning_messages.json"(exports, module2) {
     module2.exports = {
       repositories: "'repositories' (plural) Not supported. Please pick one as the 'repository' field",
       missingRepository: "No repository field.",
@@ -7628,7 +9385,7 @@ var require_warning_messages = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_make_warning = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/normalize-package-data@6.0.2/node_modules/normalize-package-data/lib/make_warning.js"(exports, module2) {
+  "../../node_modules/.pnpm/normalize-package-data@6.0.0/node_modules/normalize-package-data/lib/make_warning.js"(exports, module2) {
     "use strict";
     var util = (0, import_chunk_4VNS5WPM.__require)("util");
     var messages = require_warning_messages();
@@ -7653,7 +9410,7 @@ var require_make_warning = (0, import_chunk_4VNS5WPM.__commonJS)({
   }
 });
 var require_normalize = (0, import_chunk_4VNS5WPM.__commonJS)({
-  "../../node_modules/.pnpm/normalize-package-data@6.0.2/node_modules/normalize-package-data/lib/normalize.js"(exports, module2) {
+  "../../node_modules/.pnpm/normalize-package-data@6.0.0/node_modules/normalize-package-data/lib/normalize.js"(exports, module2) {
     "use strict";
     module2.exports = normalize;
     var fixer = require_fixer();
@@ -7689,7 +9446,7 @@ var require_normalize = (0, import_chunk_4VNS5WPM.__commonJS)({
         strict = false;
       }
       if (!warn || data.private) {
-        warn = function() {
+        warn = function(msg) {
         };
       }
       if (data.scripts && data.scripts.install === "node-gyp rebuild" && !data.scripts.preinstall) {
@@ -7727,6 +9484,778 @@ var require_unique_string = (0, import_chunk_4VNS5WPM.__commonJS)({
     module2.exports = () => cryptoRandomString(32);
   }
 });
+var require_polyfills = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/polyfills.js"(exports, module2) {
+    "use strict";
+    var constants = (0, import_chunk_4VNS5WPM.__require)("constants");
+    var origCwd = process.cwd;
+    var cwd = null;
+    var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+    process.cwd = function() {
+      if (!cwd)
+        cwd = origCwd.call(process);
+      return cwd;
+    };
+    try {
+      process.cwd();
+    } catch (er) {
+    }
+    if (typeof process.chdir === "function") {
+      chdir = process.chdir;
+      process.chdir = function(d) {
+        cwd = null;
+        chdir.call(process, d);
+      };
+      if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir);
+    }
+    var chdir;
+    module2.exports = patch;
+    function patch(fs4) {
+      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+        patchLchmod(fs4);
+      }
+      if (!fs4.lutimes) {
+        patchLutimes(fs4);
+      }
+      fs4.chown = chownFix(fs4.chown);
+      fs4.fchown = chownFix(fs4.fchown);
+      fs4.lchown = chownFix(fs4.lchown);
+      fs4.chmod = chmodFix(fs4.chmod);
+      fs4.fchmod = chmodFix(fs4.fchmod);
+      fs4.lchmod = chmodFix(fs4.lchmod);
+      fs4.chownSync = chownFixSync(fs4.chownSync);
+      fs4.fchownSync = chownFixSync(fs4.fchownSync);
+      fs4.lchownSync = chownFixSync(fs4.lchownSync);
+      fs4.chmodSync = chmodFixSync(fs4.chmodSync);
+      fs4.fchmodSync = chmodFixSync(fs4.fchmodSync);
+      fs4.lchmodSync = chmodFixSync(fs4.lchmodSync);
+      fs4.stat = statFix(fs4.stat);
+      fs4.fstat = statFix(fs4.fstat);
+      fs4.lstat = statFix(fs4.lstat);
+      fs4.statSync = statFixSync(fs4.statSync);
+      fs4.fstatSync = statFixSync(fs4.fstatSync);
+      fs4.lstatSync = statFixSync(fs4.lstatSync);
+      if (fs4.chmod && !fs4.lchmod) {
+        fs4.lchmod = function(path5, mode, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs4.lchmodSync = function() {
+        };
+      }
+      if (fs4.chown && !fs4.lchown) {
+        fs4.lchown = function(path5, uid, gid, cb) {
+          if (cb) process.nextTick(cb);
+        };
+        fs4.lchownSync = function() {
+        };
+      }
+      if (platform === "win32") {
+        fs4.rename = typeof fs4.rename !== "function" ? fs4.rename : function(fs$rename) {
+          function rename(from, to, cb) {
+            var start = Date.now();
+            var backoff = 0;
+            fs$rename(from, to, function CB(er) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 6e4) {
+                setTimeout(function() {
+                  fs4.stat(to, function(stater, st) {
+                    if (stater && stater.code === "ENOENT")
+                      fs$rename(from, to, CB);
+                    else
+                      cb(er);
+                  });
+                }, backoff);
+                if (backoff < 100)
+                  backoff += 10;
+                return;
+              }
+              if (cb) cb(er);
+            });
+          }
+          if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
+          return rename;
+        }(fs4.rename);
+      }
+      fs4.read = typeof fs4.read !== "function" ? fs4.read : function(fs$read) {
+        function read(fd, buffer, offset, length, position, callback_) {
+          var callback;
+          if (callback_ && typeof callback_ === "function") {
+            var eagCounter = 0;
+            callback = function(er, _, __) {
+              if (er && er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
+              }
+              callback_.apply(this, arguments);
+            };
+          }
+          return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
+        }
+        if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
+        return read;
+      }(fs4.read);
+      fs4.readSync = typeof fs4.readSync !== "function" ? fs4.readSync : /* @__PURE__ */ function(fs$readSync) {
+        return function(fd, buffer, offset, length, position) {
+          var eagCounter = 0;
+          while (true) {
+            try {
+              return fs$readSync.call(fs4, fd, buffer, offset, length, position);
+            } catch (er) {
+              if (er.code === "EAGAIN" && eagCounter < 10) {
+                eagCounter++;
+                continue;
+              }
+              throw er;
+            }
+          }
+        };
+      }(fs4.readSync);
+      function patchLchmod(fs5) {
+        fs5.lchmod = function(path5, mode, callback) {
+          fs5.open(
+            path5,
+            constants.O_WRONLY | constants.O_SYMLINK,
+            mode,
+            function(err, fd) {
+              if (err) {
+                if (callback) callback(err);
+                return;
+              }
+              fs5.fchmod(fd, mode, function(err2) {
+                fs5.close(fd, function(err22) {
+                  if (callback) callback(err2 || err22);
+                });
+              });
+            }
+          );
+        };
+        fs5.lchmodSync = function(path5, mode) {
+          var fd = fs5.openSync(path5, constants.O_WRONLY | constants.O_SYMLINK, mode);
+          var threw = true;
+          var ret;
+          try {
+            ret = fs5.fchmodSync(fd, mode);
+            threw = false;
+          } finally {
+            if (threw) {
+              try {
+                fs5.closeSync(fd);
+              } catch (er) {
+              }
+            } else {
+              fs5.closeSync(fd);
+            }
+          }
+          return ret;
+        };
+      }
+      function patchLutimes(fs5) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs5.futimes) {
+          fs5.lutimes = function(path5, at, mt, cb) {
+            fs5.open(path5, constants.O_SYMLINK, function(er, fd) {
+              if (er) {
+                if (cb) cb(er);
+                return;
+              }
+              fs5.futimes(fd, at, mt, function(er2) {
+                fs5.close(fd, function(er22) {
+                  if (cb) cb(er2 || er22);
+                });
+              });
+            });
+          };
+          fs5.lutimesSync = function(path5, at, mt) {
+            var fd = fs5.openSync(path5, constants.O_SYMLINK);
+            var ret;
+            var threw = true;
+            try {
+              ret = fs5.futimesSync(fd, at, mt);
+              threw = false;
+            } finally {
+              if (threw) {
+                try {
+                  fs5.closeSync(fd);
+                } catch (er) {
+                }
+              } else {
+                fs5.closeSync(fd);
+              }
+            }
+            return ret;
+          };
+        } else if (fs5.futimes) {
+          fs5.lutimes = function(_a, _b, _c, cb) {
+            if (cb) process.nextTick(cb);
+          };
+          fs5.lutimesSync = function() {
+          };
+        }
+      }
+      function chmodFix(orig) {
+        if (!orig) return orig;
+        return function(target, mode, cb) {
+          return orig.call(fs4, target, mode, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      function chmodFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, mode) {
+          try {
+            return orig.call(fs4, target, mode);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function chownFix(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid, cb) {
+          return orig.call(fs4, target, uid, gid, function(er) {
+            if (chownErOk(er)) er = null;
+            if (cb) cb.apply(this, arguments);
+          });
+        };
+      }
+      function chownFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, uid, gid) {
+          try {
+            return orig.call(fs4, target, uid, gid);
+          } catch (er) {
+            if (!chownErOk(er)) throw er;
+          }
+        };
+      }
+      function statFix(orig) {
+        if (!orig) return orig;
+        return function(target, options, cb) {
+          if (typeof options === "function") {
+            cb = options;
+            options = null;
+          }
+          function callback(er, stats) {
+            if (stats) {
+              if (stats.uid < 0) stats.uid += 4294967296;
+              if (stats.gid < 0) stats.gid += 4294967296;
+            }
+            if (cb) cb.apply(this, arguments);
+          }
+          return options ? orig.call(fs4, target, options, callback) : orig.call(fs4, target, callback);
+        };
+      }
+      function statFixSync(orig) {
+        if (!orig) return orig;
+        return function(target, options) {
+          var stats = options ? orig.call(fs4, target, options) : orig.call(fs4, target);
+          if (stats) {
+            if (stats.uid < 0) stats.uid += 4294967296;
+            if (stats.gid < 0) stats.gid += 4294967296;
+          }
+          return stats;
+        };
+      }
+      function chownErOk(er) {
+        if (!er)
+          return true;
+        if (er.code === "ENOSYS")
+          return true;
+        var nonroot = !process.getuid || process.getuid() !== 0;
+        if (nonroot) {
+          if (er.code === "EINVAL" || er.code === "EPERM")
+            return true;
+        }
+        return false;
+      }
+    }
+  }
+});
+var require_legacy_streams = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/legacy-streams.js"(exports, module2) {
+    "use strict";
+    var Stream = (0, import_chunk_4VNS5WPM.__require)("stream").Stream;
+    module2.exports = legacy;
+    function legacy(fs4) {
+      return {
+        ReadStream,
+        WriteStream
+      };
+      function ReadStream(path5, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path5, options);
+        Stream.call(this);
+        var self = this;
+        this.path = path5;
+        this.fd = null;
+        this.readable = true;
+        this.paused = false;
+        this.flags = "r";
+        this.mode = 438;
+        this.bufferSize = 64 * 1024;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.encoding) this.setEncoding(this.encoding);
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.end === void 0) {
+            this.end = Infinity;
+          } else if ("number" !== typeof this.end) {
+            throw TypeError("end must be a Number");
+          }
+          if (this.start > this.end) {
+            throw new Error("start must be <= end");
+          }
+          this.pos = this.start;
+        }
+        if (this.fd !== null) {
+          process.nextTick(function() {
+            self._read();
+          });
+          return;
+        }
+        fs4.open(this.path, this.flags, this.mode, function(err, fd) {
+          if (err) {
+            self.emit("error", err);
+            self.readable = false;
+            return;
+          }
+          self.fd = fd;
+          self.emit("open", fd);
+          self._read();
+        });
+      }
+      function WriteStream(path5, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path5, options);
+        Stream.call(this);
+        this.path = path5;
+        this.fd = null;
+        this.writable = true;
+        this.flags = "w";
+        this.encoding = "binary";
+        this.mode = 438;
+        this.bytesWritten = 0;
+        options = options || {};
+        var keys = Object.keys(options);
+        for (var index = 0, length = keys.length; index < length; index++) {
+          var key = keys[index];
+          this[key] = options[key];
+        }
+        if (this.start !== void 0) {
+          if ("number" !== typeof this.start) {
+            throw TypeError("start must be a Number");
+          }
+          if (this.start < 0) {
+            throw new Error("start must be >= zero");
+          }
+          this.pos = this.start;
+        }
+        this.busy = false;
+        this._queue = [];
+        if (this.fd === null) {
+          this._open = fs4.open;
+          this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
+          this.flush();
+        }
+      }
+    }
+  }
+});
+var require_clone = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/clone.js"(exports, module2) {
+    "use strict";
+    module2.exports = clone;
+    var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+      return obj.__proto__;
+    };
+    function clone(obj) {
+      if (obj === null || typeof obj !== "object")
+        return obj;
+      if (obj instanceof Object)
+        var copy = { __proto__: getPrototypeOf(obj) };
+      else
+        var copy = /* @__PURE__ */ Object.create(null);
+      Object.getOwnPropertyNames(obj).forEach(function(key) {
+        Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key));
+      });
+      return copy;
+    }
+  }
+});
+var require_graceful_fs = (0, import_chunk_4VNS5WPM.__commonJS)({
+  "../../node_modules/.pnpm/graceful-fs@4.2.10/node_modules/graceful-fs/graceful-fs.js"(exports, module2) {
+    "use strict";
+    var fs4 = (0, import_chunk_4VNS5WPM.__require)("fs");
+    var polyfills = require_polyfills();
+    var legacy = require_legacy_streams();
+    var clone = require_clone();
+    var util = (0, import_chunk_4VNS5WPM.__require)("util");
+    var gracefulQueue;
+    var previousSymbol;
+    if (typeof Symbol === "function" && typeof Symbol.for === "function") {
+      gracefulQueue = Symbol.for("graceful-fs.queue");
+      previousSymbol = Symbol.for("graceful-fs.previous");
+    } else {
+      gracefulQueue = "___graceful-fs.queue";
+      previousSymbol = "___graceful-fs.previous";
+    }
+    function noop() {
+    }
+    function publishQueue(context, queue2) {
+      Object.defineProperty(context, gracefulQueue, {
+        get: function() {
+          return queue2;
+        }
+      });
+    }
+    var debug = noop;
+    if (util.debuglog)
+      debug = util.debuglog("gfs4");
+    else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
+      debug = function() {
+        var m = util.format.apply(util, arguments);
+        m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
+        console.error(m);
+      };
+    if (!fs4[gracefulQueue]) {
+      queue = global[gracefulQueue] || [];
+      publishQueue(fs4, queue);
+      fs4.close = function(fs$close) {
+        function close(fd, cb) {
+          return fs$close.call(fs4, fd, function(err) {
+            if (!err) {
+              resetQueue();
+            }
+            if (typeof cb === "function")
+              cb.apply(this, arguments);
+          });
+        }
+        Object.defineProperty(close, previousSymbol, {
+          value: fs$close
+        });
+        return close;
+      }(fs4.close);
+      fs4.closeSync = function(fs$closeSync) {
+        function closeSync(fd) {
+          fs$closeSync.apply(fs4, arguments);
+          resetQueue();
+        }
+        Object.defineProperty(closeSync, previousSymbol, {
+          value: fs$closeSync
+        });
+        return closeSync;
+      }(fs4.closeSync);
+      if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
+        process.on("exit", function() {
+          debug(fs4[gracefulQueue]);
+          (0, import_chunk_4VNS5WPM.__require)("assert").equal(fs4[gracefulQueue].length, 0);
+        });
+      }
+    }
+    var queue;
+    if (!global[gracefulQueue]) {
+      publishQueue(global, fs4[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs4));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs4.__patched) {
+      module2.exports = patch(fs4);
+      fs4.__patched = true;
+    }
+    function patch(fs5) {
+      polyfills(fs5);
+      fs5.gracefulify = patch;
+      fs5.createReadStream = createReadStream;
+      fs5.createWriteStream = createWriteStream;
+      var fs$readFile = fs5.readFile;
+      fs5.readFile = readFile;
+      function readFile(path5, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$readFile(path5, options, cb);
+        function go$readFile(path6, options2, cb2, startTime) {
+          return fs$readFile(path6, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$readFile, [path6, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$writeFile = fs5.writeFile;
+      fs5.writeFile = writeFile;
+      function writeFile(path5, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$writeFile(path5, data, options, cb);
+        function go$writeFile(path6, data2, options2, cb2, startTime) {
+          return fs$writeFile(path6, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$writeFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$appendFile = fs5.appendFile;
+      if (fs$appendFile)
+        fs5.appendFile = appendFile;
+      function appendFile(path5, data, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        return go$appendFile(path5, data, options, cb);
+        function go$appendFile(path6, data2, options2, cb2, startTime) {
+          return fs$appendFile(path6, data2, options2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$appendFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$copyFile = fs5.copyFile;
+      if (fs$copyFile)
+        fs5.copyFile = copyFile;
+      function copyFile(src, dest, flags, cb) {
+        if (typeof flags === "function") {
+          cb = flags;
+          flags = 0;
+        }
+        return go$copyFile(src, dest, flags, cb);
+        function go$copyFile(src2, dest2, flags2, cb2, startTime) {
+          return fs$copyFile(src2, dest2, flags2, function(err) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$copyFile, [src2, dest2, flags2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      var fs$readdir = fs5.readdir;
+      fs5.readdir = readdir;
+      var noReaddirOptionVersions = /^v[0-5]\./;
+      function readdir(path5, options, cb) {
+        if (typeof options === "function")
+          cb = options, options = null;
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path6, options2, cb2, startTime) {
+          return fs$readdir(path6, fs$readdirCallback(
+            path6,
+            options2,
+            cb2,
+            startTime
+          ));
+        } : function go$readdir2(path6, options2, cb2, startTime) {
+          return fs$readdir(path6, options2, fs$readdirCallback(
+            path6,
+            options2,
+            cb2,
+            startTime
+          ));
+        };
+        return go$readdir(path5, options, cb);
+        function fs$readdirCallback(path6, options2, cb2, startTime) {
+          return function(err, files) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([
+                go$readdir,
+                [path6, options2, cb2],
+                err,
+                startTime || Date.now(),
+                Date.now()
+              ]);
+            else {
+              if (files && files.sort)
+                files.sort();
+              if (typeof cb2 === "function")
+                cb2.call(this, err, files);
+            }
+          };
+        }
+      }
+      if (process.version.substr(0, 4) === "v0.8") {
+        var legStreams = legacy(fs5);
+        ReadStream = legStreams.ReadStream;
+        WriteStream = legStreams.WriteStream;
+      }
+      var fs$ReadStream = fs5.ReadStream;
+      if (fs$ReadStream) {
+        ReadStream.prototype = Object.create(fs$ReadStream.prototype);
+        ReadStream.prototype.open = ReadStream$open;
+      }
+      var fs$WriteStream = fs5.WriteStream;
+      if (fs$WriteStream) {
+        WriteStream.prototype = Object.create(fs$WriteStream.prototype);
+        WriteStream.prototype.open = WriteStream$open;
+      }
+      Object.defineProperty(fs5, "ReadStream", {
+        get: function() {
+          return ReadStream;
+        },
+        set: function(val) {
+          ReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      Object.defineProperty(fs5, "WriteStream", {
+        get: function() {
+          return WriteStream;
+        },
+        set: function(val) {
+          WriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileReadStream = ReadStream;
+      Object.defineProperty(fs5, "FileReadStream", {
+        get: function() {
+          return FileReadStream;
+        },
+        set: function(val) {
+          FileReadStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      var FileWriteStream = WriteStream;
+      Object.defineProperty(fs5, "FileWriteStream", {
+        get: function() {
+          return FileWriteStream;
+        },
+        set: function(val) {
+          FileWriteStream = val;
+        },
+        enumerable: true,
+        configurable: true
+      });
+      function ReadStream(path5, options) {
+        if (this instanceof ReadStream)
+          return fs$ReadStream.apply(this, arguments), this;
+        else
+          return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+      }
+      function ReadStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            if (that.autoClose)
+              that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+            that.read();
+          }
+        });
+      }
+      function WriteStream(path5, options) {
+        if (this instanceof WriteStream)
+          return fs$WriteStream.apply(this, arguments), this;
+        else
+          return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+      }
+      function WriteStream$open() {
+        var that = this;
+        open(that.path, that.flags, that.mode, function(err, fd) {
+          if (err) {
+            that.destroy();
+            that.emit("error", err);
+          } else {
+            that.fd = fd;
+            that.emit("open", fd);
+          }
+        });
+      }
+      function createReadStream(path5, options) {
+        return new fs5.ReadStream(path5, options);
+      }
+      function createWriteStream(path5, options) {
+        return new fs5.WriteStream(path5, options);
+      }
+      var fs$open = fs5.open;
+      fs5.open = open;
+      function open(path5, flags, mode, cb) {
+        if (typeof mode === "function")
+          cb = mode, mode = null;
+        return go$open(path5, flags, mode, cb);
+        function go$open(path6, flags2, mode2, cb2, startTime) {
+          return fs$open(path6, flags2, mode2, function(err, fd) {
+            if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
+              enqueue([go$open, [path6, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+            else {
+              if (typeof cb2 === "function")
+                cb2.apply(this, arguments);
+            }
+          });
+        }
+      }
+      return fs5;
+    }
+    function enqueue(elem) {
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs4[gracefulQueue].push(elem);
+      retry();
+    }
+    var retryTimer;
+    function resetQueue() {
+      var now = Date.now();
+      for (var i = 0; i < fs4[gracefulQueue].length; ++i) {
+        if (fs4[gracefulQueue][i].length > 2) {
+          fs4[gracefulQueue][i][3] = now;
+          fs4[gracefulQueue][i][4] = now;
+        }
+      }
+      retry();
+    }
+    function retry() {
+      clearTimeout(retryTimer);
+      retryTimer = void 0;
+      if (fs4[gracefulQueue].length === 0)
+        return;
+      var elem = fs4[gracefulQueue].shift();
+      var fn = elem[0];
+      var args = elem[1];
+      var err = elem[2];
+      var startTime = elem[3];
+      var lastTime = elem[4];
+      if (startTime === void 0) {
+        debug("RETRY", fn.name, args);
+        fn.apply(null, args);
+      } else if (Date.now() - startTime >= 6e4) {
+        debug("TIMEOUT", fn.name, args);
+        var cb = args.pop();
+        if (typeof cb === "function")
+          cb.call(null, err);
+      } else {
+        var sinceAttempt = Date.now() - lastTime;
+        var sinceStart = Math.max(lastTime - startTime, 1);
+        var desiredDelay = Math.min(sinceStart * 1.2, 100);
+        if (sinceAttempt >= desiredDelay) {
+          debug("RETRY", fn.name, args);
+          fn.apply(null, args.concat([startTime]));
+        } else {
+          fs4[gracefulQueue].push(elem);
+        }
+      }
+      if (retryTimer === void 0) {
+        retryTimer = setTimeout(retry, 0);
+      }
+    }
+  }
+});
 var require_is_path_cwd = (0, import_chunk_4VNS5WPM.__commonJS)({
   "../../node_modules/.pnpm/is-path-cwd@2.2.0/node_modules/is-path-cwd/index.js"(exports, module2) {
     "use strict";
@@ -10024,10 +12553,10 @@ var require_del = (0, import_chunk_4VNS5WPM.__commonJS)({
     "use strict";
     var { promisify } = (0, import_chunk_4VNS5WPM.__require)("util");
     var path5 = (0, import_chunk_4VNS5WPM.__require)("path");
-    var globby = (0, import_chunk_2LOGW45F.require_globby)();
-    var isGlob = (0, import_chunk_2LOGW45F.require_is_glob)();
-    var slash = (0, import_chunk_2LOGW45F.require_slash)();
-    var gracefulFs = (0, import_chunk_DYV47NUW.require_graceful_fs)();
+    var globby = (0, import_chunk_JOIIWB3U.require_globby)();
+    var isGlob = (0, import_chunk_JOIIWB3U.require_is_glob)();
+    var slash = (0, import_chunk_JOIIWB3U.require_slash)();
+    var gracefulFs = require_graceful_fs();
     var isPathCwd = require_is_path_cwd();
     var isPathInside = require_is_path_inside();
     var rimraf = require_rimraf();
@@ -10202,9 +12731,8 @@ async function findUp(name, {
   let directory = import_node_path2.default.resolve(toPath(cwd) ?? "");
   const { root } = import_node_path2.default.parse(directory);
   stopAt = import_node_path2.default.resolve(directory, toPath(stopAt ?? root));
-  const isAbsoluteName = import_node_path2.default.isAbsolute(name);
-  while (directory) {
-    const filePath = isAbsoluteName ? name : import_node_path2.default.join(directory, name);
+  while (directory && directory !== stopAt && directory !== root) {
+    const filePath = import_node_path2.default.isAbsolute(name) ? name : import_node_path2.default.join(directory, name);
     try {
       const stats = await import_promises.default.stat(filePath);
       if (type === "file" && stats.isFile() || type === "directory" && stats.isDirectory()) {
@@ -10212,9 +12740,6 @@ async function findUp(name, {
       }
     } catch {
     }
-    if (directory === stopAt || directory === root) {
-      break;
-    }
     directory = import_node_path2.default.dirname(directory);
   }
 }
@@ -10226,9 +12751,8 @@ function findUpSync(name, {
   let directory = import_node_path2.default.resolve(toPath(cwd) ?? "");
   const { root } = import_node_path2.default.parse(directory);
   stopAt = import_node_path2.default.resolve(directory, toPath(stopAt) ?? root);
-  const isAbsoluteName = import_node_path2.default.isAbsolute(name);
-  while (directory) {
-    const filePath = isAbsoluteName ? name : import_node_path2.default.join(directory, name);
+  while (directory && directory !== stopAt && directory !== root) {
+    const filePath = import_node_path2.default.isAbsolute(name) ? name : import_node_path2.default.join(directory, name);
     try {
       const stats = import_node_fs.default.statSync(filePath, { throwIfNoEntry: false });
       if (type === "file" && stats?.isFile() || type === "directory" && stats?.isDirectory()) {
@@ -10236,13 +12760,10 @@ function findUpSync(name, {
       }
     } catch {
     }
-    if (directory === stopAt || directory === root) {
-      break;
-    }
     directory = import_node_path2.default.dirname(directory);
   }
 }
-var import_code_frame = (0, import_chunk_4VNS5WPM.__toESM)(require_lib6(), 1);
+var import_code_frame = (0, import_chunk_4VNS5WPM.__toESM)(require_lib7(), 1);
 var safeLastIndexOf = (string, searchString, index) => index < 0 ? -1 : string.lastIndexOf(searchString, index);
 function getPosition(text, textIndex) {
   const lineBreakBefore = safeLastIndexOf(text, "\n", textIndex - 1);
@@ -10254,12 +12775,6 @@ function getPosition(text, textIndex) {
   return { line, column };
 }
 function indexToLineColumn(text, textIndex, { oneBased = false } = {}) {
-  if (typeof text !== "string") {
-    throw new TypeError("Text parameter should be a string");
-  }
-  if (!Number.isInteger(textIndex)) {
-    throw new TypeError("Index parameter should be an integer");
-  }
   if (textIndex < 0 || textIndex >= text.length && text.length > 0) {
     throw new RangeError("Index out of bounds");
   }
@@ -10270,28 +12785,17 @@ var getCodePoint = (character) => `\\u{${character.codePointAt(0).toString(16)}}
 var JSONError = class _JSONError extends Error {
   name = "JSONError";
   fileName;
-  #input;
-  #jsonParseError;
+  codeFrame;
+  rawCodeFrame;
   #message;
-  #codeFrame;
-  #rawCodeFrame;
-  constructor(messageOrOptions) {
-    if (typeof messageOrOptions === "string") {
-      super();
-      this.#message = messageOrOptions;
-    } else {
-      const { jsonParseError, fileName, input } = messageOrOptions;
-      super(void 0, { cause: jsonParseError });
-      this.#input = input;
-      this.#jsonParseError = jsonParseError;
-      this.fileName = fileName;
-    }
+  constructor(message) {
+    super();
+    this.#message = message;
     Error.captureStackTrace?.(this, _JSONError);
   }
   get message() {
-    this.#message ??= `${addCodePointToUnexpectedToken(this.#jsonParseError.message)}${this.#input === "" ? " while parsing empty string" : ""}`;
-    const { codeFrame } = this;
-    return `${this.#message}${this.fileName ? ` in ${this.fileName}` : ""}${codeFrame ? `
+    const { fileName, codeFrame } = this;
+    return `${this.#message}${fileName ? ` in ${fileName}` : ""}${codeFrame ? `
 
 ${codeFrame}
 ` : ""}`;
@@ -10299,32 +12803,8 @@ ${codeFrame}
   set message(message) {
     this.#message = message;
   }
-  #getCodeFrame(highlightCode) {
-    if (!this.#jsonParseError) {
-      return;
-    }
-    const input = this.#input;
-    const location = getErrorLocation(input, this.#jsonParseError.message);
-    if (!location) {
-      return;
-    }
-    return (0, import_code_frame.codeFrameColumns)(input, { start: location }, { highlightCode });
-  }
-  get codeFrame() {
-    this.#codeFrame ??= this.#getCodeFrame(
-      /* highlightCode */
-      true
-    );
-    return this.#codeFrame;
-  }
-  get rawCodeFrame() {
-    this.#rawCodeFrame ??= this.#getCodeFrame(
-      /* highlightCode */
-      false
-    );
-    return this.#rawCodeFrame;
-  }
 };
+var generateCodeFrame = (string, location, highlightCode = true) => (0, import_code_frame.codeFrameColumns)(string, { start: location }, { highlightCode });
 var getErrorLocation = (string, message) => {
   const match = message.match(/in JSON at position (?<index>\d+)(?: \(line (?<line>\d+) column (?<column>\d+)\))?$/);
   if (!match) {
@@ -10351,15 +12831,31 @@ function parseJson(string, reviver, fileName) {
     fileName = reviver;
     reviver = void 0;
   }
+  let message;
   try {
     return JSON.parse(string, reviver);
   } catch (error) {
-    throw new JSONError({
-      jsonParseError: error,
-      fileName,
-      input: string
-    });
+    message = error.message;
+  }
+  let location;
+  if (string) {
+    location = getErrorLocation(string, message);
+    message = addCodePointToUnexpectedToken(message);
+  } else {
+    message += " while parsing empty string";
+  }
+  const jsonError = new JSONError(message);
+  jsonError.fileName = fileName;
+  if (location) {
+    jsonError.codeFrame = generateCodeFrame(string, location);
+    jsonError.rawCodeFrame = generateCodeFrame(
+      string,
+      location,
+      /* highlightCode */
+      false
+    );
   }
+  throw jsonError;
 }
 var import_normalize_package_data = (0, import_chunk_4VNS5WPM.__toESM)(require_normalize(), 1);
 function toPath2(urlOrPath) {
@@ -10403,7 +12899,7 @@ function readPackageUpSync(options) {
 }
 var import_tempy = (0, import_chunk_4VNS5WPM.__toESM)(require_tempy());
 async function getPackedPackage(name, target, packageDir) {
-  packageDir = packageDir || await (0, import_chunk_URRVX2VQ.resolvePkg)(name, { basedir: process.cwd() }) || await (0, import_chunk_URRVX2VQ.resolvePkg)(name, { basedir: target });
+  packageDir = packageDir || await (0, import_chunk_VVPSLVOR.resolvePkg)(name, { basedir: process.cwd() }) || await (0, import_chunk_VVPSLVOR.resolvePkg)(name, { basedir: target });
   if (!packageDir) {
     const pkg = readPackageUpSync({
       cwd: target,