@teams-max/mwsp 1.0.2 → 2.0.1

package/lib/utils/chalk/index.js

@@ -0,0 +1,1538 @@
+// src/utils/chalk/index.js
+module.exports = (() => {
+  var e = {
+    68: (e2, t2, n) => {
+      "use strict";
+      e2 = n.nmd(e2);
+      const r = (e3, t3) => (...n2) => {
+        const r2 = e3(...n2);
+        return `\x1B[${r2 + t3}m`;
+      };
+      const o = (e3, t3) => (...n2) => {
+        const r2 = e3(...n2);
+        return `\x1B[${38 + t3};5;${r2}m`;
+      };
+      const s = (e3, t3) => (...n2) => {
+        const r2 = e3(...n2);
+        return `\x1B[${38 + t3};2;${r2[0]};${r2[1]};${r2[2]}m`;
+      };
+      const l = (e3) => e3;
+      const c = (e3, t3, n2) => [e3, t3, n2];
+      const i = (e3, t3, n2) => {
+        Object.defineProperty(e3, t3, {
+          get: () => {
+            const r2 = n2();
+            Object.defineProperty(e3, t3, {
+              value: r2,
+              enumerable: true,
+              configurable: true
+            });
+            return r2;
+          },
+          enumerable: true,
+          configurable: true
+        });
+      };
+      let a;
+      const u = (e3, t3, r2, o2) => {
+        if (a === void 0) {
+          a = n(53);
+        }
+        const s2 = o2 ? 10 : 0;
+        const l2 = {};
+        for (const [n2, o3] of Object.entries(a)) {
+          const c2 = n2 === "ansi16" ? "ansi" : n2;
+          if (n2 === t3) {
+            l2[c2] = e3(r2, s2);
+          } else if (typeof o3 === "object") {
+            l2[c2] = e3(o3[t3], s2);
+          }
+        }
+        return l2;
+      };
+      function assembleStyles() {
+        const e3 = /* @__PURE__ */ new Map();
+        const t3 = {
+          modifier: {
+            reset: [0, 0],
+            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],
+            blackBright: [90, 39],
+            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],
+            bgBlackBright: [100, 49],
+            bgRedBright: [101, 49],
+            bgGreenBright: [102, 49],
+            bgYellowBright: [103, 49],
+            bgBlueBright: [104, 49],
+            bgMagentaBright: [105, 49],
+            bgCyanBright: [106, 49],
+            bgWhiteBright: [107, 49]
+          }
+        };
+        t3.color.gray = t3.color.blackBright;
+        t3.bgColor.bgGray = t3.bgColor.bgBlackBright;
+        t3.color.grey = t3.color.blackBright;
+        t3.bgColor.bgGrey = t3.bgColor.bgBlackBright;
+        for (const [n2, r2] of Object.entries(t3)) {
+          for (const [n3, o2] of Object.entries(r2)) {
+            t3[n3] = { open: `\x1B[${o2[0]}m`, close: `\x1B[${o2[1]}m` };
+            r2[n3] = t3[n3];
+            e3.set(o2[0], o2[1]);
+          }
+          Object.defineProperty(t3, n2, { value: r2, enumerable: false });
+        }
+        Object.defineProperty(t3, "codes", { value: e3, enumerable: false });
+        t3.color.close = "\x1B[39m";
+        t3.bgColor.close = "\x1B[49m";
+        i(t3.color, "ansi", () => u(r, "ansi16", l, false));
+        i(t3.color, "ansi256", () => u(o, "ansi256", l, false));
+        i(t3.color, "ansi16m", () => u(s, "rgb", c, false));
+        i(t3.bgColor, "ansi", () => u(r, "ansi16", l, true));
+        i(t3.bgColor, "ansi256", () => u(o, "ansi256", l, true));
+        i(t3.bgColor, "ansi16m", () => u(s, "rgb", c, true));
+        return t3;
+      }
+      Object.defineProperty(e2, "exports", {
+        enumerable: true,
+        get: assembleStyles
+      });
+    },
+    294: (e2, t2, n) => {
+      const r = n(510);
+      const o = {};
+      for (const e3 of Object.keys(r)) {
+        o[r[e3]] = e3;
+      }
+      const s = {
+        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"] }
+      };
+      e2.exports = s;
+      for (const e3 of Object.keys(s)) {
+        if (!("channels" in s[e3])) {
+          throw new Error("missing channels property: " + e3);
+        }
+        if (!("labels" in s[e3])) {
+          throw new Error("missing channel labels property: " + e3);
+        }
+        if (s[e3].labels.length !== s[e3].channels) {
+          throw new Error("channel and label counts mismatch: " + e3);
+        }
+        const { channels: t3, labels: n2 } = s[e3];
+        delete s[e3].channels;
+        delete s[e3].labels;
+        Object.defineProperty(s[e3], "channels", { value: t3 });
+        Object.defineProperty(s[e3], "labels", { value: n2 });
+      }
+      s.rgb.hsl = function(e3) {
+        const t3 = e3[0] / 255;
+        const n2 = e3[1] / 255;
+        const r2 = e3[2] / 255;
+        const o2 = Math.min(t3, n2, r2);
+        const s2 = Math.max(t3, n2, r2);
+        const l = s2 - o2;
+        let c;
+        let i;
+        if (s2 === o2) {
+          c = 0;
+        } else if (t3 === s2) {
+          c = (n2 - r2) / l;
+        } else if (n2 === s2) {
+          c = 2 + (r2 - t3) / l;
+        } else if (r2 === s2) {
+          c = 4 + (t3 - n2) / l;
+        }
+        c = Math.min(c * 60, 360);
+        if (c < 0) {
+          c += 360;
+        }
+        const a = (o2 + s2) / 2;
+        if (s2 === o2) {
+          i = 0;
+        } else if (a <= 0.5) {
+          i = l / (s2 + o2);
+        } else {
+          i = l / (2 - s2 - o2);
+        }
+        return [c, i * 100, a * 100];
+      };
+      s.rgb.hsv = function(e3) {
+        let t3;
+        let n2;
+        let r2;
+        let o2;
+        let s2;
+        const l = e3[0] / 255;
+        const c = e3[1] / 255;
+        const i = e3[2] / 255;
+        const a = Math.max(l, c, i);
+        const u = a - Math.min(l, c, i);
+        const f = function(e4) {
+          return (a - e4) / 6 / u + 1 / 2;
+        };
+        if (u === 0) {
+          o2 = 0;
+          s2 = 0;
+        } else {
+          s2 = u / a;
+          t3 = f(l);
+          n2 = f(c);
+          r2 = f(i);
+          if (l === a) {
+            o2 = r2 - n2;
+          } else if (c === a) {
+            o2 = 1 / 3 + t3 - r2;
+          } else if (i === a) {
+            o2 = 2 / 3 + n2 - t3;
+          }
+          if (o2 < 0) {
+            o2 += 1;
+          } else if (o2 > 1) {
+            o2 -= 1;
+          }
+        }
+        return [o2 * 360, s2 * 100, a * 100];
+      };
+      s.rgb.hwb = function(e3) {
+        const t3 = e3[0];
+        const n2 = e3[1];
+        let r2 = e3[2];
+        const o2 = s.rgb.hsl(e3)[0];
+        const l = 1 / 255 * Math.min(t3, Math.min(n2, r2));
+        r2 = 1 - 1 / 255 * Math.max(t3, Math.max(n2, r2));
+        return [o2, l * 100, r2 * 100];
+      };
+      s.rgb.cmyk = function(e3) {
+        const t3 = e3[0] / 255;
+        const n2 = e3[1] / 255;
+        const r2 = e3[2] / 255;
+        const o2 = Math.min(1 - t3, 1 - n2, 1 - r2);
+        const s2 = (1 - t3 - o2) / (1 - o2) || 0;
+        const l = (1 - n2 - o2) / (1 - o2) || 0;
+        const c = (1 - r2 - o2) / (1 - o2) || 0;
+        return [s2 * 100, l * 100, c * 100, o2 * 100];
+      };
+      function comparativeDistance(e3, t3) {
+        return (e3[0] - t3[0]) ** 2 + (e3[1] - t3[1]) ** 2 + (e3[2] - t3[2]) ** 2;
+      }
+      s.rgb.keyword = function(e3) {
+        const t3 = o[e3];
+        if (t3) {
+          return t3;
+        }
+        let n2 = Infinity;
+        let s2;
+        for (const t4 of Object.keys(r)) {
+          const o2 = r[t4];
+          const l = comparativeDistance(e3, o2);
+          if (l < n2) {
+            n2 = l;
+            s2 = t4;
+          }
+        }
+        return s2;
+      };
+      s.keyword.rgb = function(e3) {
+        return r[e3];
+      };
+      s.rgb.xyz = function(e3) {
+        let t3 = e3[0] / 255;
+        let n2 = e3[1] / 255;
+        let r2 = e3[2] / 255;
+        t3 = t3 > 0.04045 ? ((t3 + 0.055) / 1.055) ** 2.4 : t3 / 12.92;
+        n2 = n2 > 0.04045 ? ((n2 + 0.055) / 1.055) ** 2.4 : n2 / 12.92;
+        r2 = r2 > 0.04045 ? ((r2 + 0.055) / 1.055) ** 2.4 : r2 / 12.92;
+        const o2 = t3 * 0.4124 + n2 * 0.3576 + r2 * 0.1805;
+        const s2 = t3 * 0.2126 + n2 * 0.7152 + r2 * 0.0722;
+        const l = t3 * 0.0193 + n2 * 0.1192 + r2 * 0.9505;
+        return [o2 * 100, s2 * 100, l * 100];
+      };
+      s.rgb.lab = function(e3) {
+        const t3 = s.rgb.xyz(e3);
+        let n2 = t3[0];
+        let r2 = t3[1];
+        let o2 = t3[2];
+        n2 /= 95.047;
+        r2 /= 100;
+        o2 /= 108.883;
+        n2 = n2 > 8856e-6 ? n2 ** (1 / 3) : 7.787 * n2 + 16 / 116;
+        r2 = r2 > 8856e-6 ? r2 ** (1 / 3) : 7.787 * r2 + 16 / 116;
+        o2 = o2 > 8856e-6 ? o2 ** (1 / 3) : 7.787 * o2 + 16 / 116;
+        const l = 116 * r2 - 16;
+        const c = 500 * (n2 - r2);
+        const i = 200 * (r2 - o2);
+        return [l, c, i];
+      };
+      s.hsl.rgb = function(e3) {
+        const t3 = e3[0] / 360;
+        const n2 = e3[1] / 100;
+        const r2 = e3[2] / 100;
+        let o2;
+        let s2;
+        let l;
+        if (n2 === 0) {
+          l = r2 * 255;
+          return [l, l, l];
+        }
+        if (r2 < 0.5) {
+          o2 = r2 * (1 + n2);
+        } else {
+          o2 = r2 + n2 - r2 * n2;
+        }
+        const c = 2 * r2 - o2;
+        const i = [0, 0, 0];
+        for (let e4 = 0; e4 < 3; e4++) {
+          s2 = t3 + 1 / 3 * -(e4 - 1);
+          if (s2 < 0) {
+            s2++;
+          }
+          if (s2 > 1) {
+            s2--;
+          }
+          if (6 * s2 < 1) {
+            l = c + (o2 - c) * 6 * s2;
+          } else if (2 * s2 < 1) {
+            l = o2;
+          } else if (3 * s2 < 2) {
+            l = c + (o2 - c) * (2 / 3 - s2) * 6;
+          } else {
+            l = c;
+          }
+          i[e4] = l * 255;
+        }
+        return i;
+      };
+      s.hsl.hsv = function(e3) {
+        const t3 = e3[0];
+        let n2 = e3[1] / 100;
+        let r2 = e3[2] / 100;
+        let o2 = n2;
+        const s2 = Math.max(r2, 0.01);
+        r2 *= 2;
+        n2 *= r2 <= 1 ? r2 : 2 - r2;
+        o2 *= s2 <= 1 ? s2 : 2 - s2;
+        const l = (r2 + n2) / 2;
+        const c = r2 === 0 ? 2 * o2 / (s2 + o2) : 2 * n2 / (r2 + n2);
+        return [t3, c * 100, l * 100];
+      };
+      s.hsv.rgb = function(e3) {
+        const t3 = e3[0] / 60;
+        const n2 = e3[1] / 100;
+        let r2 = e3[2] / 100;
+        const o2 = Math.floor(t3) % 6;
+        const s2 = t3 - Math.floor(t3);
+        const l = 255 * r2 * (1 - n2);
+        const c = 255 * r2 * (1 - n2 * s2);
+        const i = 255 * r2 * (1 - n2 * (1 - s2));
+        r2 *= 255;
+        switch (o2) {
+          case 0:
+            return [r2, i, l];
+          case 1:
+            return [c, r2, l];
+          case 2:
+            return [l, r2, i];
+          case 3:
+            return [l, c, r2];
+          case 4:
+            return [i, l, r2];
+          case 5:
+            return [r2, l, c];
+        }
+      };
+      s.hsv.hsl = function(e3) {
+        const t3 = e3[0];
+        const n2 = e3[1] / 100;
+        const r2 = e3[2] / 100;
+        const o2 = Math.max(r2, 0.01);
+        let s2;
+        let l;
+        l = (2 - n2) * r2;
+        const c = (2 - n2) * o2;
+        s2 = n2 * o2;
+        s2 /= c <= 1 ? c : 2 - c;
+        s2 = s2 || 0;
+        l /= 2;
+        return [t3, s2 * 100, l * 100];
+      };
+      s.hwb.rgb = function(e3) {
+        const t3 = e3[0] / 360;
+        let n2 = e3[1] / 100;
+        let r2 = e3[2] / 100;
+        const o2 = n2 + r2;
+        let s2;
+        if (o2 > 1) {
+          n2 /= o2;
+          r2 /= o2;
+        }
+        const l = Math.floor(6 * t3);
+        const c = 1 - r2;
+        s2 = 6 * t3 - l;
+        if ((l & 1) !== 0) {
+          s2 = 1 - s2;
+        }
+        const i = n2 + s2 * (c - n2);
+        let a;
+        let u;
+        let f;
+        switch (l) {
+          default:
+          case 6:
+          case 0:
+            a = c;
+            u = i;
+            f = n2;
+            break;
+          case 1:
+            a = i;
+            u = c;
+            f = n2;
+            break;
+          case 2:
+            a = n2;
+            u = c;
+            f = i;
+            break;
+          case 3:
+            a = n2;
+            u = i;
+            f = c;
+            break;
+          case 4:
+            a = i;
+            u = n2;
+            f = c;
+            break;
+          case 5:
+            a = c;
+            u = n2;
+            f = i;
+            break;
+        }
+        return [a * 255, u * 255, f * 255];
+      };
+      s.cmyk.rgb = function(e3) {
+        const t3 = e3[0] / 100;
+        const n2 = e3[1] / 100;
+        const r2 = e3[2] / 100;
+        const o2 = e3[3] / 100;
+        const s2 = 1 - Math.min(1, t3 * (1 - o2) + o2);
+        const l = 1 - Math.min(1, n2 * (1 - o2) + o2);
+        const c = 1 - Math.min(1, r2 * (1 - o2) + o2);
+        return [s2 * 255, l * 255, c * 255];
+      };
+      s.xyz.rgb = function(e3) {
+        const t3 = e3[0] / 100;
+        const n2 = e3[1] / 100;
+        const r2 = e3[2] / 100;
+        let o2;
+        let s2;
+        let l;
+        o2 = t3 * 3.2406 + n2 * -1.5372 + r2 * -0.4986;
+        s2 = t3 * -0.9689 + n2 * 1.8758 + r2 * 0.0415;
+        l = t3 * 0.0557 + n2 * -0.204 + r2 * 1.057;
+        o2 = o2 > 31308e-7 ? 1.055 * o2 ** (1 / 2.4) - 0.055 : o2 * 12.92;
+        s2 = s2 > 31308e-7 ? 1.055 * s2 ** (1 / 2.4) - 0.055 : s2 * 12.92;
+        l = l > 31308e-7 ? 1.055 * l ** (1 / 2.4) - 0.055 : l * 12.92;
+        o2 = Math.min(Math.max(0, o2), 1);
+        s2 = Math.min(Math.max(0, s2), 1);
+        l = Math.min(Math.max(0, l), 1);
+        return [o2 * 255, s2 * 255, l * 255];
+      };
+      s.xyz.lab = function(e3) {
+        let t3 = e3[0];
+        let n2 = e3[1];
+        let r2 = e3[2];
+        t3 /= 95.047;
+        n2 /= 100;
+        r2 /= 108.883;
+        t3 = t3 > 8856e-6 ? t3 ** (1 / 3) : 7.787 * t3 + 16 / 116;
+        n2 = n2 > 8856e-6 ? n2 ** (1 / 3) : 7.787 * n2 + 16 / 116;
+        r2 = r2 > 8856e-6 ? r2 ** (1 / 3) : 7.787 * r2 + 16 / 116;
+        const o2 = 116 * n2 - 16;
+        const s2 = 500 * (t3 - n2);
+        const l = 200 * (n2 - r2);
+        return [o2, s2, l];
+      };
+      s.lab.xyz = function(e3) {
+        const t3 = e3[0];
+        const n2 = e3[1];
+        const r2 = e3[2];
+        let o2;
+        let s2;
+        let l;
+        s2 = (t3 + 16) / 116;
+        o2 = n2 / 500 + s2;
+        l = s2 - r2 / 200;
+        const c = s2 ** 3;
+        const i = o2 ** 3;
+        const a = l ** 3;
+        s2 = c > 8856e-6 ? c : (s2 - 16 / 116) / 7.787;
+        o2 = i > 8856e-6 ? i : (o2 - 16 / 116) / 7.787;
+        l = a > 8856e-6 ? a : (l - 16 / 116) / 7.787;
+        o2 *= 95.047;
+        s2 *= 100;
+        l *= 108.883;
+        return [o2, s2, l];
+      };
+      s.lab.lch = function(e3) {
+        const t3 = e3[0];
+        const n2 = e3[1];
+        const r2 = e3[2];
+        let o2;
+        const s2 = Math.atan2(r2, n2);
+        o2 = s2 * 360 / 2 / Math.PI;
+        if (o2 < 0) {
+          o2 += 360;
+        }
+        const l = Math.sqrt(n2 * n2 + r2 * r2);
+        return [t3, l, o2];
+      };
+      s.lch.lab = function(e3) {
+        const t3 = e3[0];
+        const n2 = e3[1];
+        const r2 = e3[2];
+        const o2 = r2 / 360 * 2 * Math.PI;
+        const s2 = n2 * Math.cos(o2);
+        const l = n2 * Math.sin(o2);
+        return [t3, s2, l];
+      };
+      s.rgb.ansi16 = function(e3, t3 = null) {
+        const [n2, r2, o2] = e3;
+        let l = t3 === null ? s.rgb.hsv(e3)[2] : t3;
+        l = Math.round(l / 50);
+        if (l === 0) {
+          return 30;
+        }
+        let c = 30 + (Math.round(o2 / 255) << 2 | Math.round(r2 / 255) << 1 | Math.round(n2 / 255));
+        if (l === 2) {
+          c += 60;
+        }
+        return c;
+      };
+      s.hsv.ansi16 = function(e3) {
+        return s.rgb.ansi16(s.hsv.rgb(e3), e3[2]);
+      };
+      s.rgb.ansi256 = function(e3) {
+        const t3 = e3[0];
+        const n2 = e3[1];
+        const r2 = e3[2];
+        if (t3 === n2 && n2 === r2) {
+          if (t3 < 8) {
+            return 16;
+          }
+          if (t3 > 248) {
+            return 231;
+          }
+          return Math.round((t3 - 8) / 247 * 24) + 232;
+        }
+        const o2 = 16 + 36 * Math.round(t3 / 255 * 5) + 6 * Math.round(n2 / 255 * 5) + Math.round(r2 / 255 * 5);
+        return o2;
+      };
+      s.ansi16.rgb = function(e3) {
+        let t3 = e3 % 10;
+        if (t3 === 0 || t3 === 7) {
+          if (e3 > 50) {
+            t3 += 3.5;
+          }
+          t3 = t3 / 10.5 * 255;
+          return [t3, t3, t3];
+        }
+        const n2 = (~~(e3 > 50) + 1) * 0.5;
+        const r2 = (t3 & 1) * n2 * 255;
+        const o2 = (t3 >> 1 & 1) * n2 * 255;
+        const s2 = (t3 >> 2 & 1) * n2 * 255;
+        return [r2, o2, s2];
+      };
+      s.ansi256.rgb = function(e3) {
+        if (e3 >= 232) {
+          const t4 = (e3 - 232) * 10 + 8;
+          return [t4, t4, t4];
+        }
+        e3 -= 16;
+        let t3;
+        const n2 = Math.floor(e3 / 36) / 5 * 255;
+        const r2 = Math.floor((t3 = e3 % 36) / 6) / 5 * 255;
+        const o2 = t3 % 6 / 5 * 255;
+        return [n2, r2, o2];
+      };
+      s.rgb.hex = function(e3) {
+        const t3 = ((Math.round(e3[0]) & 255) << 16) + ((Math.round(e3[1]) & 255) << 8) + (Math.round(e3[2]) & 255);
+        const n2 = t3.toString(16).toUpperCase();
+        return "000000".substring(n2.length) + n2;
+      };
+      s.hex.rgb = function(e3) {
+        const t3 = e3.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+        if (!t3) {
+          return [0, 0, 0];
+        }
+        let n2 = t3[0];
+        if (t3[0].length === 3) {
+          n2 = n2.split("").map((e4) => {
+            return e4 + e4;
+          }).join("");
+        }
+        const r2 = parseInt(n2, 16);
+        const o2 = r2 >> 16 & 255;
+        const s2 = r2 >> 8 & 255;
+        const l = r2 & 255;
+        return [o2, s2, l];
+      };
+      s.rgb.hcg = function(e3) {
+        const t3 = e3[0] / 255;
+        const n2 = e3[1] / 255;
+        const r2 = e3[2] / 255;
+        const o2 = Math.max(Math.max(t3, n2), r2);
+        const s2 = Math.min(Math.min(t3, n2), r2);
+        const l = o2 - s2;
+        let c;
+        let i;
+        if (l < 1) {
+          c = s2 / (1 - l);
+        } else {
+          c = 0;
+        }
+        if (l <= 0) {
+          i = 0;
+        } else if (o2 === t3) {
+          i = (n2 - r2) / l % 6;
+        } else if (o2 === n2) {
+          i = 2 + (r2 - t3) / l;
+        } else {
+          i = 4 + (t3 - n2) / l;
+        }
+        i /= 6;
+        i %= 1;
+        return [i * 360, l * 100, c * 100];
+      };
+      s.hsl.hcg = function(e3) {
+        const t3 = e3[1] / 100;
+        const n2 = e3[2] / 100;
+        const r2 = n2 < 0.5 ? 2 * t3 * n2 : 2 * t3 * (1 - n2);
+        let o2 = 0;
+        if (r2 < 1) {
+          o2 = (n2 - 0.5 * r2) / (1 - r2);
+        }
+        return [e3[0], r2 * 100, o2 * 100];
+      };
+      s.hsv.hcg = function(e3) {
+        const t3 = e3[1] / 100;
+        const n2 = e3[2] / 100;
+        const r2 = t3 * n2;
+        let o2 = 0;
+        if (r2 < 1) {
+          o2 = (n2 - r2) / (1 - r2);
+        }
+        return [e3[0], r2 * 100, o2 * 100];
+      };
+      s.hcg.rgb = function(e3) {
+        const t3 = e3[0] / 360;
+        const n2 = e3[1] / 100;
+        const r2 = e3[2] / 100;
+        if (n2 === 0) {
+          return [r2 * 255, r2 * 255, r2 * 255];
+        }
+        const o2 = [0, 0, 0];
+        const s2 = t3 % 1 * 6;
+        const l = s2 % 1;
+        const c = 1 - l;
+        let i = 0;
+        switch (Math.floor(s2)) {
+          case 0:
+            o2[0] = 1;
+            o2[1] = l;
+            o2[2] = 0;
+            break;
+          case 1:
+            o2[0] = c;
+            o2[1] = 1;
+            o2[2] = 0;
+            break;
+          case 2:
+            o2[0] = 0;
+            o2[1] = 1;
+            o2[2] = l;
+            break;
+          case 3:
+            o2[0] = 0;
+            o2[1] = c;
+            o2[2] = 1;
+            break;
+          case 4:
+            o2[0] = l;
+            o2[1] = 0;
+            o2[2] = 1;
+            break;
+          default:
+            o2[0] = 1;
+            o2[1] = 0;
+            o2[2] = c;
+        }
+        i = (1 - n2) * r2;
+        return [
+          (n2 * o2[0] + i) * 255,
+          (n2 * o2[1] + i) * 255,
+          (n2 * o2[2] + i) * 255
+        ];
+      };
+      s.hcg.hsv = function(e3) {
+        const t3 = e3[1] / 100;
+        const n2 = e3[2] / 100;
+        const r2 = t3 + n2 * (1 - t3);
+        let o2 = 0;
+        if (r2 > 0) {
+          o2 = t3 / r2;
+        }
+        return [e3[0], o2 * 100, r2 * 100];
+      };
+      s.hcg.hsl = function(e3) {
+        const t3 = e3[1] / 100;
+        const n2 = e3[2] / 100;
+        const r2 = n2 * (1 - t3) + 0.5 * t3;
+        let o2 = 0;
+        if (r2 > 0 && r2 < 0.5) {
+          o2 = t3 / (2 * r2);
+        } else if (r2 >= 0.5 && r2 < 1) {
+          o2 = t3 / (2 * (1 - r2));
+        }
+        return [e3[0], o2 * 100, r2 * 100];
+      };
+      s.hcg.hwb = function(e3) {
+        const t3 = e3[1] / 100;
+        const n2 = e3[2] / 100;
+        const r2 = t3 + n2 * (1 - t3);
+        return [e3[0], (r2 - t3) * 100, (1 - r2) * 100];
+      };
+      s.hwb.hcg = function(e3) {
+        const t3 = e3[1] / 100;
+        const n2 = e3[2] / 100;
+        const r2 = 1 - n2;
+        const o2 = r2 - t3;
+        let s2 = 0;
+        if (o2 < 1) {
+          s2 = (r2 - o2) / (1 - o2);
+        }
+        return [e3[0], o2 * 100, s2 * 100];
+      };
+      s.apple.rgb = function(e3) {
+        return [
+          e3[0] / 65535 * 255,
+          e3[1] / 65535 * 255,
+          e3[2] / 65535 * 255
+        ];
+      };
+      s.rgb.apple = function(e3) {
+        return [
+          e3[0] / 255 * 65535,
+          e3[1] / 255 * 65535,
+          e3[2] / 255 * 65535
+        ];
+      };
+      s.gray.rgb = function(e3) {
+        return [e3[0] / 100 * 255, e3[0] / 100 * 255, e3[0] / 100 * 255];
+      };
+      s.gray.hsl = function(e3) {
+        return [0, 0, e3[0]];
+      };
+      s.gray.hsv = s.gray.hsl;
+      s.gray.hwb = function(e3) {
+        return [0, 100, e3[0]];
+      };
+      s.gray.cmyk = function(e3) {
+        return [0, 0, 0, e3[0]];
+      };
+      s.gray.lab = function(e3) {
+        return [e3[0], 0, 0];
+      };
+      s.gray.hex = function(e3) {
+        const t3 = Math.round(e3[0] / 100 * 255) & 255;
+        const n2 = (t3 << 16) + (t3 << 8) + t3;
+        const r2 = n2.toString(16).toUpperCase();
+        return "000000".substring(r2.length) + r2;
+      };
+      s.rgb.gray = function(e3) {
+        const t3 = (e3[0] + e3[1] + e3[2]) / 3;
+        return [t3 / 255 * 100];
+      };
+    },
+    53: (e2, t2, n) => {
+      const r = n(294);
+      const o = n(586);
+      const s = {};
+      const l = Object.keys(r);
+      function wrapRaw(e3) {
+        const t3 = function(...t4) {
+          const n2 = t4[0];
+          if (n2 === void 0 || n2 === null) {
+            return n2;
+          }
+          if (n2.length > 1) {
+            t4 = n2;
+          }
+          return e3(t4);
+        };
+        if ("conversion" in e3) {
+          t3.conversion = e3.conversion;
+        }
+        return t3;
+      }
+      function wrapRounded(e3) {
+        const t3 = function(...t4) {
+          const n2 = t4[0];
+          if (n2 === void 0 || n2 === null) {
+            return n2;
+          }
+          if (n2.length > 1) {
+            t4 = n2;
+          }
+          const r2 = e3(t4);
+          if (typeof r2 === "object") {
+            for (let e4 = r2.length, t5 = 0; t5 < e4; t5++) {
+              r2[t5] = Math.round(r2[t5]);
+            }
+          }
+          return r2;
+        };
+        if ("conversion" in e3) {
+          t3.conversion = e3.conversion;
+        }
+        return t3;
+      }
+      l.forEach((e3) => {
+        s[e3] = {};
+        Object.defineProperty(s[e3], "channels", { value: r[e3].channels });
+        Object.defineProperty(s[e3], "labels", { value: r[e3].labels });
+        const t3 = o(e3);
+        const n2 = Object.keys(t3);
+        n2.forEach((n3) => {
+          const r2 = t3[n3];
+          s[e3][n3] = wrapRounded(r2);
+          s[e3][n3].raw = wrapRaw(r2);
+        });
+      });
+      e2.exports = s;
+    },
+    586: (e2, t2, n) => {
+      const r = n(294);
+      function buildGraph() {
+        const e3 = {};
+        const t3 = Object.keys(r);
+        for (let n2 = t3.length, r2 = 0; r2 < n2; r2++) {
+          e3[t3[r2]] = { distance: -1, parent: null };
+        }
+        return e3;
+      }
+      function deriveBFS(e3) {
+        const t3 = buildGraph();
+        const n2 = [e3];
+        t3[e3].distance = 0;
+        while (n2.length) {
+          const e4 = n2.pop();
+          const o = Object.keys(r[e4]);
+          for (let r2 = o.length, s = 0; s < r2; s++) {
+            const r3 = o[s];
+            const l = t3[r3];
+            if (l.distance === -1) {
+              l.distance = t3[e4].distance + 1;
+              l.parent = e4;
+              n2.unshift(r3);
+            }
+          }
+        }
+        return t3;
+      }
+      function link(e3, t3) {
+        return function(n2) {
+          return t3(e3(n2));
+        };
+      }
+      function wrapConversion(e3, t3) {
+        const n2 = [t3[e3].parent, e3];
+        let o = r[t3[e3].parent][e3];
+        let s = t3[e3].parent;
+        while (t3[s].parent) {
+          n2.unshift(t3[s].parent);
+          o = link(r[t3[s].parent][s], o);
+          s = t3[s].parent;
+        }
+        o.conversion = n2;
+        return o;
+      }
+      e2.exports = function(e3) {
+        const t3 = deriveBFS(e3);
+        const n2 = {};
+        const r2 = Object.keys(t3);
+        for (let e4 = r2.length, o = 0; o < e4; o++) {
+          const e5 = r2[o];
+          const s = t3[e5];
+          if (s.parent === null) {
+            continue;
+          }
+          n2[e5] = wrapConversion(e5, t3);
+        }
+        return n2;
+      };
+    },
+    538: (e2) => {
+      "use strict";
+      e2.exports = (e3, t2 = process.argv) => {
+        const n = e3.startsWith("-") ? "" : e3.length === 1 ? "-" : "--";
+        const r = t2.indexOf(n + e3);
+        const o = t2.indexOf("--");
+        return r !== -1 && (o === -1 || r < o);
+      };
+    },
+    955: (e2, t2, n) => {
+      "use strict";
+      const r = n(87);
+      const o = n(867);
+      const s = n(538);
+      const { env: l } = process;
+      let c;
+      if (s("no-color") || s("no-colors") || s("color=false") || s("color=never")) {
+        c = 0;
+      } else if (s("color") || s("colors") || s("color=true") || s("color=always")) {
+        c = 1;
+      }
+      if ("FORCE_COLOR" in l) {
+        if (l.FORCE_COLOR === "true") {
+          c = 1;
+        } else if (l.FORCE_COLOR === "false") {
+          c = 0;
+        } else {
+          c = l.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(l.FORCE_COLOR, 10), 3);
+        }
+      }
+      function translateLevel(e3) {
+        if (e3 === 0) {
+          return false;
+        }
+        return { level: e3, hasBasic: true, has256: e3 >= 2, has16m: e3 >= 3 };
+      }
+      function supportsColor(e3, t3) {
+        if (c === 0) {
+          return 0;
+        }
+        if (s("color=16m") || s("color=full") || s("color=truecolor")) {
+          return 3;
+        }
+        if (s("color=256")) {
+          return 2;
+        }
+        if (e3 && !t3 && c === void 0) {
+          return 0;
+        }
+        const n2 = c || 0;
+        if (l.TERM === "dumb") {
+          return n2;
+        }
+        if (process.platform === "win32") {
+          const e4 = r.release().split(".");
+          if (Number(e4[0]) >= 10 && Number(e4[2]) >= 10586) {
+            return Number(e4[2]) >= 14931 ? 3 : 2;
+          }
+          return 1;
+        }
+        if ("CI" in l) {
+          if ([
+            "TRAVIS",
+            "CIRCLECI",
+            "APPVEYOR",
+            "GITLAB_CI",
+            "GITHUB_ACTIONS",
+            "BUILDKITE"
+          ].some((e4) => e4 in l) || l.CI_NAME === "codeship") {
+            return 1;
+          }
+          return n2;
+        }
+        if ("TEAMCITY_VERSION" in l) {
+          return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(l.TEAMCITY_VERSION) ? 1 : 0;
+        }
+        if (l.COLORTERM === "truecolor") {
+          return 3;
+        }
+        if ("TERM_PROGRAM" in l) {
+          const e4 = parseInt((l.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+          switch (l.TERM_PROGRAM) {
+            case "iTerm.app":
+              return e4 >= 3 ? 3 : 2;
+            case "Apple_Terminal":
+              return 2;
+          }
+        }
+        if (/-256(color)?$/i.test(l.TERM)) {
+          return 2;
+        }
+        if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(
+          l.TERM
+        )) {
+          return 1;
+        }
+        if ("COLORTERM" in l) {
+          return 1;
+        }
+        return n2;
+      }
+      function getSupportLevel(e3) {
+        const t3 = supportsColor(e3, e3 && e3.isTTY);
+        return translateLevel(t3);
+      }
+      e2.exports = {
+        supportsColor: getSupportLevel,
+        stdout: translateLevel(supportsColor(true, o.isatty(1))),
+        stderr: translateLevel(supportsColor(true, o.isatty(2)))
+      };
+    },
+    818: (e2, t2, n) => {
+      "use strict";
+      const r = n(68);
+      const { stdout: o, stderr: s } = n(955);
+      const { stringReplaceAll: l, stringEncaseCRLFWithFirstIndex: c } = n(415);
+      const { isArray: i } = Array;
+      const a = ["ansi", "ansi", "ansi256", "ansi16m"];
+      const u = /* @__PURE__ */ Object.create(null);
+      const f = (e3, t3 = {}) => {
+        if (t3.level && !(Number.isInteger(t3.level) && t3.level >= 0 && t3.level <= 3)) {
+          throw new Error(
+            "The `level` option should be an integer from 0 to 3"
+          );
+        }
+        const n2 = o ? o.level : 0;
+        e3.level = t3.level === void 0 ? n2 : t3.level;
+      };
+      class ChalkClass {
+        constructor(e3) {
+          return h(e3);
+        }
+      }
+      const h = (e3) => {
+        const t3 = {};
+        f(t3, e3);
+        t3.template = (...e4) => w(t3.template, ...e4);
+        Object.setPrototypeOf(t3, Chalk.prototype);
+        Object.setPrototypeOf(t3.template, t3);
+        t3.template.constructor = () => {
+          throw new Error(
+            "`chalk.constructor()` is deprecated. Use `new chalk.Instance()` instead."
+          );
+        };
+        t3.template.Instance = ChalkClass;
+        return t3.template;
+      };
+      function Chalk(e3) {
+        return h(e3);
+      }
+      for (const [e3, t3] of Object.entries(r)) {
+        u[e3] = {
+          get() {
+            const n2 = d(this, p(t3.open, t3.close, this._styler), this._isEmpty);
+            Object.defineProperty(this, e3, { value: n2 });
+            return n2;
+          }
+        };
+      }
+      u.visible = {
+        get() {
+          const e3 = d(this, this._styler, true);
+          Object.defineProperty(this, "visible", { value: e3 });
+          return e3;
+        }
+      };
+      const g = [
+        "rgb",
+        "hex",
+        "keyword",
+        "hsl",
+        "hsv",
+        "hwb",
+        "ansi",
+        "ansi256"
+      ];
+      for (const e3 of g) {
+        u[e3] = {
+          get() {
+            const { level: t3 } = this;
+            return function(...n2) {
+              const o2 = p(r.color[a[t3]][e3](...n2), r.color.close, this._styler);
+              return d(this, o2, this._isEmpty);
+            };
+          }
+        };
+      }
+      for (const e3 of g) {
+        const t3 = "bg" + e3[0].toUpperCase() + e3.slice(1);
+        u[t3] = {
+          get() {
+            const { level: t4 } = this;
+            return function(...n2) {
+              const o2 = p(
+                r.bgColor[a[t4]][e3](...n2),
+                r.bgColor.close,
+                this._styler
+              );
+              return d(this, o2, this._isEmpty);
+            };
+          }
+        };
+      }
+      const b = Object.defineProperties(() => {
+      }, {
+        ...u,
+        level: {
+          enumerable: true,
+          get() {
+            return this._generator.level;
+          },
+          set(e3) {
+            this._generator.level = e3;
+          }
+        }
+      });
+      const p = (e3, t3, n2) => {
+        let r2;
+        let o2;
+        if (n2 === void 0) {
+          r2 = e3;
+          o2 = t3;
+        } else {
+          r2 = n2.openAll + e3;
+          o2 = t3 + n2.closeAll;
+        }
+        return { open: e3, close: t3, openAll: r2, closeAll: o2, parent: n2 };
+      };
+      const d = (e3, t3, n2) => {
+        const r2 = (...e4) => {
+          if (i(e4[0]) && i(e4[0].raw)) {
+            return m(r2, w(r2, ...e4));
+          }
+          return m(r2, e4.length === 1 ? "" + e4[0] : e4.join(" "));
+        };
+        Object.setPrototypeOf(r2, b);
+        r2._generator = e3;
+        r2._styler = t3;
+        r2._isEmpty = n2;
+        return r2;
+      };
+      const m = (e3, t3) => {
+        if (e3.level <= 0 || !t3) {
+          return e3._isEmpty ? "" : t3;
+        }
+        let n2 = e3._styler;
+        if (n2 === void 0) {
+          return t3;
+        }
+        const { openAll: r2, closeAll: o2 } = n2;
+        if (t3.indexOf("\x1B") !== -1) {
+          while (n2 !== void 0) {
+            t3 = l(t3, n2.close, n2.open);
+            n2 = n2.parent;
+          }
+        }
+        const s2 = t3.indexOf("\n");
+        if (s2 !== -1) {
+          t3 = c(t3, o2, r2, s2);
+        }
+        return r2 + t3 + o2;
+      };
+      let y;
+      const w = (e3, ...t3) => {
+        const [r2] = t3;
+        if (!i(r2) || !i(r2.raw)) {
+          return t3.join(" ");
+        }
+        const o2 = t3.slice(1);
+        const s2 = [r2.raw[0]];
+        for (let e4 = 1; e4 < r2.length; e4++) {
+          s2.push(String(o2[e4 - 1]).replace(/[{}\\]/g, "\\$&"), String(r2.raw[e4]));
+        }
+        if (y === void 0) {
+          y = n(500);
+        }
+        return y(e3, s2.join(""));
+      };
+      Object.defineProperties(Chalk.prototype, u);
+      const v = Chalk();
+      v.supportsColor = o;
+      v.stderr = Chalk({ level: s ? s.level : 0 });
+      v.stderr.supportsColor = s;
+      e2.exports = v;
+    },
+    500: (e2) => {
+      "use strict";
+      const t2 = /(?:\\(u(?:[a-f\d]{4}|\{[a-f\d]{1,6}\})|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+      const n = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+      const r = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+      const o = /\\(u(?:[a-f\d]{4}|{[a-f\d]{1,6}})|x[a-f\d]{2}|.)|([^\\])/gi;
+      const s = /* @__PURE__ */ new Map([
+        ["n", "\n"],
+        ["r", "\r"],
+        ["t", "	"],
+        ["b", "\b"],
+        ["f", "\f"],
+        ["v", "\v"],
+        ["0", "\0"],
+        ["\\", "\\"],
+        ["e", "\x1B"],
+        ["a", "\x07"]
+      ]);
+      function unescape(e3) {
+        const t3 = e3[0] === "u";
+        const n2 = e3[1] === "{";
+        if (t3 && !n2 && e3.length === 5 || e3[0] === "x" && e3.length === 3) {
+          return String.fromCharCode(parseInt(e3.slice(1), 16));
+        }
+        if (t3 && n2) {
+          return String.fromCodePoint(parseInt(e3.slice(2, -1), 16));
+        }
+        return s.get(e3) || e3;
+      }
+      function parseArguments(e3, t3) {
+        const n2 = [];
+        const s2 = t3.trim().split(/\s*,\s*/g);
+        let l;
+        for (const t4 of s2) {
+          const s3 = Number(t4);
+          if (!Number.isNaN(s3)) {
+            n2.push(s3);
+          } else if (l = t4.match(r)) {
+            n2.push(l[2].replace(o, (e4, t5, n3) => t5 ? unescape(t5) : n3));
+          } else {
+            throw new Error(
+              `Invalid Chalk template style argument: ${t4} (in style '${e3}')`
+            );
+          }
+        }
+        return n2;
+      }
+      function parseStyle(e3) {
+        n.lastIndex = 0;
+        const t3 = [];
+        let r2;
+        while ((r2 = n.exec(e3)) !== null) {
+          const e4 = r2[1];
+          if (r2[2]) {
+            const n2 = parseArguments(e4, r2[2]);
+            t3.push([e4].concat(n2));
+          } else {
+            t3.push([e4]);
+          }
+        }
+        return t3;
+      }
+      function buildStyle(e3, t3) {
+        const n2 = {};
+        for (const e4 of t3) {
+          for (const t4 of e4.styles) {
+            n2[t4[0]] = e4.inverse ? null : t4.slice(1);
+          }
+        }
+        let r2 = e3;
+        for (const [e4, t4] of Object.entries(n2)) {
+          if (!Array.isArray(t4)) {
+            continue;
+          }
+          if (!(e4 in r2)) {
+            throw new Error(`Unknown Chalk style: ${e4}`);
+          }
+          r2 = t4.length > 0 ? r2[e4](...t4) : r2[e4];
+        }
+        return r2;
+      }
+      e2.exports = (e3, n2) => {
+        const r2 = [];
+        const o2 = [];
+        let s2 = [];
+        n2.replace(t2, (t3, n3, l, c, i, a) => {
+          if (n3) {
+            s2.push(unescape(n3));
+          } else if (c) {
+            const t4 = s2.join("");
+            s2 = [];
+            o2.push(r2.length === 0 ? t4 : buildStyle(e3, r2)(t4));
+            r2.push({ inverse: l, styles: parseStyle(c) });
+          } else if (i) {
+            if (r2.length === 0) {
+              throw new Error("Found extraneous } in Chalk template literal");
+            }
+            o2.push(buildStyle(e3, r2)(s2.join("")));
+            s2 = [];
+            r2.pop();
+          } else {
+            s2.push(a);
+          }
+        });
+        o2.push(s2.join(""));
+        if (r2.length > 0) {
+          const e4 = `Chalk template literal is missing ${r2.length} closing bracket${r2.length === 1 ? "" : "s"} (\`}\`)`;
+          throw new Error(e4);
+        }
+        return o2.join("");
+      };
+    },
+    415: (e2) => {
+      "use strict";
+      const t2 = (e3, t3, n2) => {
+        let r = e3.indexOf(t3);
+        if (r === -1) {
+          return e3;
+        }
+        const o = t3.length;
+        let s = 0;
+        let l = "";
+        do {
+          l += e3.substr(s, r - s) + t3 + n2;
+          s = r + o;
+          r = e3.indexOf(t3, s);
+        } while (r !== -1);
+        l += e3.substr(s);
+        return l;
+      };
+      const n = (e3, t3, n2, r) => {
+        let o = 0;
+        let s = "";
+        do {
+          const l = e3[r - 1] === "\r";
+          s += e3.substr(o, (l ? r - 1 : r) - o) + t3 + (l ? "\r\n" : "\n") + n2;
+          o = r + 1;
+          r = e3.indexOf("\n", o);
+        } while (r !== -1);
+        s += e3.substr(o);
+        return s;
+      };
+      e2.exports = { stringReplaceAll: t2, stringEncaseCRLFWithFirstIndex: n };
+    },
+    510: (e2) => {
+      "use strict";
+      e2.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]
+      };
+    },
+    87: (e2) => {
+      "use strict";
+      e2.exports = require("os");
+    },
+    867: (e2) => {
+      "use strict";
+      e2.exports = require("tty");
+    }
+  };
+  var t = {};
+  function __nccwpck_require__(n) {
+    if (t[n]) {
+      return t[n].exports;
+    }
+    var r = t[n] = { id: n, loaded: false, exports: {} };
+    var o = true;
+    try {
+      e[n](r, r.exports, __nccwpck_require__);
+      o = false;
+    } finally {
+      if (o)
+        delete t[n];
+    }
+    r.loaded = true;
+    return r.exports;
+  }
+  (() => {
+    __nccwpck_require__.nmd = (e2) => {
+      e2.paths = [];
+      if (!e2.children)
+        e2.children = [];
+      return e2;
+    };
+  })();
+  __nccwpck_require__.ab = __dirname + "/";
+  return __nccwpck_require__(818);
+})();