@bleedingdev/modern-js-utils 3.9.0-ultramodern.9 → 3.9.3-ultramodern.1

package/dist/compiled/signale/index.js

@@ -1,29 +1,2265 @@
 (()=>{
     var e = {
-        305: (e, t, r)=>{
+        151: (e, r, t)=>{
             "use strict";
-            var n = r(837);
-            var i = r(589);
-            var s = function(e, t) {
+            e = t.nmd(e);
+            const n = t(550);
+            const wrapAnsi16 = (e, r)=>function() {
+                    const t = e.apply(n, arguments);
+                    return `[${t + r}m`;
+                };
+            const wrapAnsi256 = (e, r)=>function() {
+                    const t = e.apply(n, arguments);
+                    return `[${38 + r};5;${t}m`;
+                };
+            const wrapAnsi16m = (e, r)=>function() {
+                    const t = e.apply(n, arguments);
+                    return `[${38 + r};2;${t[0]};${t[1]};${t[2]}m`;
+                };
+            function assembleStyles() {
+                const e = new Map;
+                const r = {
+                    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
+                        ],
+                        gray: [
+                            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
+                        ]
+                    }
+                };
+                r.color.grey = r.color.gray;
+                for (const t of Object.keys(r)){
+                    const n = r[t];
+                    for (const t of Object.keys(n)){
+                        const i = n[t];
+                        r[t] = {
+                            open: `[${i[0]}m`,
+                            close: `[${i[1]}m`
+                        };
+                        n[t] = r[t];
+                        e.set(i[0], i[1]);
+                    }
+                    Object.defineProperty(r, t, {
+                        value: n,
+                        enumerable: false
+                    });
+                    Object.defineProperty(r, "codes", {
+                        value: e,
+                        enumerable: false
+                    });
+                }
+                const ansi2ansi = (e)=>e;
+                const rgb2rgb = (e, r, t)=>[
+                        e,
+                        r,
+                        t
+                    ];
+                r.color.close = "";
+                r.bgColor.close = "";
+                r.color.ansi = {
+                    ansi: wrapAnsi16(ansi2ansi, 0)
+                };
+                r.color.ansi256 = {
+                    ansi256: wrapAnsi256(ansi2ansi, 0)
+                };
+                r.color.ansi16m = {
+                    rgb: wrapAnsi16m(rgb2rgb, 0)
+                };
+                r.bgColor.ansi = {
+                    ansi: wrapAnsi16(ansi2ansi, 10)
+                };
+                r.bgColor.ansi256 = {
+                    ansi256: wrapAnsi256(ansi2ansi, 10)
+                };
+                r.bgColor.ansi16m = {
+                    rgb: wrapAnsi16m(rgb2rgb, 10)
+                };
+                for (let e of Object.keys(n)){
+                    if ("object" != typeof n[e]) continue;
+                    const t = n[e];
+                    if ("ansi16" === e) e = "ansi";
+                    if ("ansi16" in t) {
+                        r.color.ansi[e] = wrapAnsi16(t.ansi16, 0);
+                        r.bgColor.ansi[e] = wrapAnsi16(t.ansi16, 10);
+                    }
+                    if ("ansi256" in t) {
+                        r.color.ansi256[e] = wrapAnsi256(t.ansi256, 0);
+                        r.bgColor.ansi256[e] = wrapAnsi256(t.ansi256, 10);
+                    }
+                    if ("rgb" in t) {
+                        r.color.ansi16m[e] = wrapAnsi16m(t.rgb, 0);
+                        r.bgColor.ansi16m[e] = wrapAnsi16m(t.rgb, 10);
+                    }
+                }
+                return r;
+            }
+            Object.defineProperty(e, "exports", {
+                enumerable: true,
+                get: assembleStyles
+            });
+        },
+        425: (e, r, t)=>{
+            "use strict";
+            const n = t(767);
+            const i = t(151);
+            const a = t(791).stdout;
+            const s = t(374);
+            const o = "win32" === process.platform && !(process.env.TERM || "").toLowerCase().startsWith("xterm");
+            const c = [
+                "ansi",
+                "ansi",
+                "ansi256",
+                "ansi16m"
+            ];
+            const l = new Set([
+                "gray"
+            ]);
+            const u = Object.create(null);
+            function applyOptions(e, r) {
+                r = r || {};
+                const t = a ? a.level : 0;
+                e.level = void 0 === r.level ? t : r.level;
+                e.enabled = "enabled" in r ? r.enabled : e.level > 0;
+            }
+            function Chalk(e) {
+                if (!this || !(this instanceof Chalk) || this.template) {
+                    const r = {};
+                    applyOptions(r, e);
+                    r.template = function() {
+                        const e = [].slice.call(arguments);
+                        return chalkTag.apply(null, [
+                            r.template
+                        ].concat(e));
+                    };
+                    Object.setPrototypeOf(r, Chalk.prototype);
+                    Object.setPrototypeOf(r.template, r);
+                    r.template.constructor = Chalk;
+                    return r.template;
+                }
+                applyOptions(this, e);
+            }
+            if (o) i.blue.open = "";
+            for (const e of Object.keys(i)){
+                i[e].closeRe = new RegExp(n(i[e].close), "g");
+                u[e] = {
+                    get () {
+                        const r = i[e];
+                        return build.call(this, this._styles ? this._styles.concat(r) : [
+                            r
+                        ], this._empty, e);
+                    }
+                };
+            }
+            u.visible = {
+                get () {
+                    return build.call(this, this._styles || [], true, "visible");
+                }
+            };
+            i.color.closeRe = new RegExp(n(i.color.close), "g");
+            for (const e of Object.keys(i.color.ansi))if (!l.has(e)) u[e] = {
+                get () {
+                    const r = this.level;
+                    return function() {
+                        const t = i.color[c[r]][e].apply(null, arguments);
+                        const n = {
+                            open: t,
+                            close: i.color.close,
+                            closeRe: i.color.closeRe
+                        };
+                        return build.call(this, this._styles ? this._styles.concat(n) : [
+                            n
+                        ], this._empty, e);
+                    };
+                }
+            };
+            i.bgColor.closeRe = new RegExp(n(i.bgColor.close), "g");
+            for (const e of Object.keys(i.bgColor.ansi)){
+                if (l.has(e)) continue;
+                const r = "bg" + e[0].toUpperCase() + e.slice(1);
+                u[r] = {
+                    get () {
+                        const r = this.level;
+                        return function() {
+                            const t = i.bgColor[c[r]][e].apply(null, arguments);
+                            const n = {
+                                open: t,
+                                close: i.bgColor.close,
+                                closeRe: i.bgColor.closeRe
+                            };
+                            return build.call(this, this._styles ? this._styles.concat(n) : [
+                                n
+                            ], this._empty, e);
+                        };
+                    }
+                };
+            }
+            const f = Object.defineProperties(()=>{}, u);
+            function build(e, r, t) {
+                const builder = function() {
+                    return applyStyle.apply(builder, arguments);
+                };
+                builder._styles = e;
+                builder._empty = r;
+                const n = this;
+                Object.defineProperty(builder, "level", {
+                    enumerable: true,
+                    get () {
+                        return n.level;
+                    },
+                    set (e) {
+                        n.level = e;
+                    }
+                });
+                Object.defineProperty(builder, "enabled", {
+                    enumerable: true,
+                    get () {
+                        return n.enabled;
+                    },
+                    set (e) {
+                        n.enabled = e;
+                    }
+                });
+                builder.hasGrey = this.hasGrey || "gray" === t || "grey" === t;
+                builder.__proto__ = f;
+                return builder;
+            }
+            function applyStyle() {
+                const e = arguments;
+                const r = e.length;
+                let t = String(arguments[0]);
+                if (0 === r) return "";
+                if (r > 1) for(let n = 1; n < r; n++)t += " " + e[n];
+                if (!this.enabled || this.level <= 0 || !t) return this._empty ? "" : t;
+                const n = i.dim.open;
+                if (o && this.hasGrey) i.dim.open = "";
+                for (const e of this._styles.slice().reverse()){
+                    t = e.open + t.replace(e.closeRe, e.open) + e.close;
+                    t = t.replace(/\r?\n/g, `${e.close}$&${e.open}`);
+                }
+                i.dim.open = n;
+                return t;
+            }
+            function chalkTag(e, r) {
+                if (!Array.isArray(r)) return [].slice.call(arguments, 1).join(" ");
+                const t = [].slice.call(arguments, 2);
+                const n = [
+                    r.raw[0]
+                ];
+                for(let e = 1; e < r.length; e++){
+                    n.push(String(t[e - 1]).replace(/[{}\\]/g, "\\$&"));
+                    n.push(String(r.raw[e]));
+                }
+                return s(e, n.join(""));
+            }
+            Object.defineProperties(Chalk.prototype, u);
+            e.exports = Chalk();
+            e.exports.supportsColor = a;
+            e.exports["default"] = e.exports;
+        },
+        374: (e)=>{
+            "use strict";
+            const r = /(?:\\(u[a-f\d]{4}|x[a-f\d]{2}|.))|(?:\{(~)?(\w+(?:\([^)]*\))?(?:\.\w+(?:\([^)]*\))?)*)(?:[ \t]|(?=\r?\n)))|(\})|((?:.|[\r\n\f])+?)/gi;
+            const t = /(?:^|\.)(\w+)(?:\(([^)]*)\))?/g;
+            const n = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/;
+            const i = /\\(u[a-f\d]{4}|x[a-f\d]{2}|.)|([^\\])/gi;
+            const a = new Map([
+                [
+                    "n",
+                    "\n"
+                ],
+                [
+                    "r",
+                    "\r"
+                ],
+                [
+                    "t",
+                    "\t"
+                ],
+                [
+                    "b",
+                    "\b"
+                ],
+                [
+                    "f",
+                    "\f"
+                ],
+                [
+                    "v",
+                    "\v"
+                ],
+                [
+                    "0",
+                    "\0"
+                ],
+                [
+                    "\\",
+                    "\\"
+                ],
+                [
+                    "e",
+                    ""
+                ],
+                [
+                    "a",
+                    ""
+                ]
+            ]);
+            function unescape(e) {
+                if ("u" === e[0] && 5 === e.length || "x" === e[0] && 3 === e.length) return String.fromCharCode(parseInt(e.slice(1), 16));
+                return a.get(e) || e;
+            }
+            function parseArguments(e, r) {
+                const t = [];
+                const a = r.trim().split(/\s*,\s*/g);
+                let s;
+                for (const r of a)if (isNaN(r)) if (s = r.match(n)) t.push(s[2].replace(i, (e, r, t)=>r ? unescape(r) : t));
+                else throw new Error(`Invalid Chalk template style argument: ${r} (in style '${e}')`);
+                else t.push(Number(r));
+                return t;
+            }
+            function parseStyle(e) {
+                t.lastIndex = 0;
+                const r = [];
+                let n;
+                while(null !== (n = t.exec(e))){
+                    const e = n[1];
+                    if (n[2]) {
+                        const t = parseArguments(e, n[2]);
+                        r.push([
+                            e
+                        ].concat(t));
+                    } else r.push([
+                        e
+                    ]);
+                }
+                return r;
+            }
+            function buildStyle(e, r) {
+                const t = {};
+                for (const e of r)for (const r of e.styles)t[r[0]] = e.inverse ? null : r.slice(1);
+                let n = e;
+                for (const e of Object.keys(t))if (Array.isArray(t[e])) {
+                    if (!(e in n)) throw new Error(`Unknown Chalk style: ${e}`);
+                    n = t[e].length > 0 ? n[e].apply(n, t[e]) : n[e];
+                }
+                return n;
+            }
+            e.exports = (e, t)=>{
+                const n = [];
+                const i = [];
+                let a = [];
+                t.replace(r, (r, t, s, o, c, l)=>{
+                    if (t) a.push(unescape(t));
+                    else if (o) {
+                        const r = a.join("");
+                        a = [];
+                        i.push(0 === n.length ? r : buildStyle(e, n)(r));
+                        n.push({
+                            inverse: s,
+                            styles: parseStyle(o)
+                        });
+                    } else if (c) {
+                        if (0 === n.length) throw new Error("Found extraneous } in Chalk template literal");
+                        i.push(buildStyle(e, n)(a.join("")));
+                        a = [];
+                        n.pop();
+                    } else a.push(l);
+                });
+                i.push(a.join(""));
+                if (n.length > 0) {
+                    const e = `Chalk template literal is missing ${n.length} closing bracket${1 === n.length ? "" : "s"} (\`}\`)`;
+                    throw new Error(e);
+                }
+                return i.join("");
+            };
+        },
+        899: (e, r, t)=>{
+            var n = t(130);
+            var i = {};
+            for(var a in n)if (n.hasOwnProperty(a)) i[n[a]] = a;
+            var s = e.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(var o in s)if (s.hasOwnProperty(o)) {
+                if (!("channels" in s[o])) throw new Error("missing channels property: " + o);
+                if (!("labels" in s[o])) throw new Error("missing channel labels property: " + o);
+                if (s[o].labels.length !== s[o].channels) throw new Error("channel and label counts mismatch: " + o);
+                var c = s[o].channels;
+                var l = s[o].labels;
+                delete s[o].channels;
+                delete s[o].labels;
+                Object.defineProperty(s[o], "channels", {
+                    value: c
+                });
+                Object.defineProperty(s[o], "labels", {
+                    value: l
+                });
+            }
+            s.rgb.hsl = function(e) {
+                var r = e[0] / 255;
+                var t = e[1] / 255;
+                var n = e[2] / 255;
+                var i = Math.min(r, t, n);
+                var a = Math.max(r, t, n);
+                var s = a - i;
+                var o;
+                var c;
+                var l;
+                if (a === i) o = 0;
+                else if (r === a) o = (t - n) / s;
+                else if (t === a) o = 2 + (n - r) / s;
+                else if (n === a) o = 4 + (r - t) / s;
+                o = Math.min(60 * o, 360);
+                if (o < 0) o += 360;
+                l = (i + a) / 2;
+                c = a === i ? 0 : l <= .5 ? s / (a + i) : s / (2 - a - i);
+                return [
+                    o,
+                    100 * c,
+                    100 * l
+                ];
+            };
+            s.rgb.hsv = function(e) {
+                var r;
+                var t;
+                var n;
+                var i;
+                var a;
+                var s = e[0] / 255;
+                var o = e[1] / 255;
+                var c = e[2] / 255;
+                var l = Math.max(s, o, c);
+                var u = l - Math.min(s, o, c);
+                var diffc = function(e) {
+                    return (l - e) / 6 / u + 0.5;
+                };
+                if (0 === u) i = a = 0;
+                else {
+                    a = u / l;
+                    r = diffc(s);
+                    t = diffc(o);
+                    n = diffc(c);
+                    if (s === l) i = n - t;
+                    else if (o === l) i = 1 / 3 + r - n;
+                    else if (c === l) i = 2 / 3 + t - r;
+                    if (i < 0) i += 1;
+                    else if (i > 1) i -= 1;
+                }
+                return [
+                    360 * i,
+                    100 * a,
+                    100 * l
+                ];
+            };
+            s.rgb.hwb = function(e) {
+                var r = e[0];
+                var t = e[1];
+                var n = e[2];
+                var i = s.rgb.hsl(e)[0];
+                var a = 1 / 255 * Math.min(r, Math.min(t, n));
+                n = 1 - 1 / 255 * Math.max(r, Math.max(t, n));
+                return [
+                    i,
+                    100 * a,
+                    100 * n
+                ];
+            };
+            s.rgb.cmyk = function(e) {
+                var r = e[0] / 255;
+                var t = e[1] / 255;
+                var n = e[2] / 255;
+                var i;
+                var a;
+                var s;
+                var o;
+                o = Math.min(1 - r, 1 - t, 1 - n);
+                i = (1 - r - o) / (1 - o) || 0;
+                a = (1 - t - o) / (1 - o) || 0;
+                s = (1 - n - o) / (1 - o) || 0;
+                return [
+                    100 * i,
+                    100 * a,
+                    100 * s,
+                    100 * o
+                ];
+            };
+            function comparativeDistance(e, r) {
+                return Math.pow(e[0] - r[0], 2) + Math.pow(e[1] - r[1], 2) + Math.pow(e[2] - r[2], 2);
+            }
+            s.rgb.keyword = function(e) {
+                var r = i[e];
+                if (r) return r;
+                var t = 1 / 0;
+                var a;
+                for(var s in n)if (n.hasOwnProperty(s)) {
+                    var o = n[s];
+                    var c = comparativeDistance(e, o);
+                    if (c < t) {
+                        t = c;
+                        a = s;
+                    }
+                }
+                return a;
+            };
+            s.keyword.rgb = function(e) {
+                return n[e];
+            };
+            s.rgb.xyz = function(e) {
+                var r = e[0] / 255;
+                var t = e[1] / 255;
+                var n = e[2] / 255;
+                r = r > .04045 ? Math.pow((r + .055) / 1.055, 2.4) : r / 12.92;
+                t = t > .04045 ? Math.pow((t + .055) / 1.055, 2.4) : t / 12.92;
+                n = n > .04045 ? Math.pow((n + .055) / 1.055, 2.4) : n / 12.92;
+                var i = .4124 * r + .3576 * t + .1805 * n;
+                var a = .2126 * r + .7152 * t + .0722 * n;
+                var s = .0193 * r + .1192 * t + .9505 * n;
+                return [
+                    100 * i,
+                    100 * a,
+                    100 * s
+                ];
+            };
+            s.rgb.lab = function(e) {
+                var r = s.rgb.xyz(e);
+                var t = r[0];
+                var n = r[1];
+                var i = r[2];
+                var a;
+                var o;
+                var c;
+                t /= 95.047;
+                n /= 100;
+                i /= 108.883;
+                t = t > .008856 ? Math.pow(t, 1 / 3) : 7.787 * t + 16 / 116;
+                n = n > .008856 ? Math.pow(n, 1 / 3) : 7.787 * n + 16 / 116;
+                i = i > .008856 ? Math.pow(i, 1 / 3) : 7.787 * i + 16 / 116;
+                a = 116 * n - 16;
+                o = 500 * (t - n);
+                c = 200 * (n - i);
+                return [
+                    a,
+                    o,
+                    c
+                ];
+            };
+            s.hsl.rgb = function(e) {
+                var r = e[0] / 360;
+                var t = e[1] / 100;
+                var n = e[2] / 100;
+                var i;
+                var a;
+                var s;
+                var o;
+                var c;
+                if (0 === t) {
+                    c = 255 * n;
+                    return [
+                        c,
+                        c,
+                        c
+                    ];
+                }
+                a = n < .5 ? n * (1 + t) : n + t - n * t;
+                i = 2 * n - a;
+                o = [
+                    0,
+                    0,
+                    0
+                ];
+                for(var l = 0; l < 3; l++){
+                    s = r + 1 / 3 * -(l - 1);
+                    if (s < 0) s++;
+                    if (s > 1) s--;
+                    c = 6 * s < 1 ? i + (a - i) * 6 * s : 2 * s < 1 ? a : 3 * s < 2 ? i + (a - i) * (2 / 3 - s) * 6 : i;
+                    o[l] = 255 * c;
+                }
+                return o;
+            };
+            s.hsl.hsv = function(e) {
+                var r = e[0];
+                var t = e[1] / 100;
+                var n = e[2] / 100;
+                var i = t;
+                var a = Math.max(n, .01);
+                var s;
+                var o;
+                n *= 2;
+                t *= n <= 1 ? n : 2 - n;
+                i *= a <= 1 ? a : 2 - a;
+                o = (n + t) / 2;
+                s = 0 === n ? 2 * i / (a + i) : 2 * t / (n + t);
+                return [
+                    r,
+                    100 * s,
+                    100 * o
+                ];
+            };
+            s.hsv.rgb = function(e) {
+                var r = e[0] / 60;
+                var t = e[1] / 100;
+                var n = e[2] / 100;
+                var i = Math.floor(r) % 6;
+                var a = r - Math.floor(r);
+                var s = 255 * n * (1 - t);
+                var o = 255 * n * (1 - t * a);
+                var c = 255 * n * (1 - t * (1 - a));
+                n *= 255;
+                switch(i){
+                    case 0:
+                        return [
+                            n,
+                            c,
+                            s
+                        ];
+                    case 1:
+                        return [
+                            o,
+                            n,
+                            s
+                        ];
+                    case 2:
+                        return [
+                            s,
+                            n,
+                            c
+                        ];
+                    case 3:
+                        return [
+                            s,
+                            o,
+                            n
+                        ];
+                    case 4:
+                        return [
+                            c,
+                            s,
+                            n
+                        ];
+                    case 5:
+                        return [
+                            n,
+                            s,
+                            o
+                        ];
+                }
+            };
+            s.hsv.hsl = function(e) {
+                var r = e[0];
+                var t = e[1] / 100;
+                var n = e[2] / 100;
+                var i = Math.max(n, .01);
+                var a;
+                var s;
+                var o;
+                o = (2 - t) * n;
+                a = (2 - t) * i;
+                s = t * i;
+                s /= a <= 1 ? a : 2 - a;
+                s = s || 0;
+                o /= 2;
+                return [
+                    r,
+                    100 * s,
+                    100 * o
+                ];
+            };
+            s.hwb.rgb = function(e) {
+                var r = e[0] / 360;
+                var t = e[1] / 100;
+                var n = e[2] / 100;
+                var i = t + n;
+                var a;
+                var s;
+                var o;
+                var c;
+                if (i > 1) {
+                    t /= i;
+                    n /= i;
+                }
+                a = Math.floor(6 * r);
+                s = 1 - n;
+                o = 6 * r - a;
+                if ((1 & a) !== 0) o = 1 - o;
+                c = t + o * (s - t);
+                var l;
+                var u;
+                var f;
+                switch(a){
+                    default:
+                    case 6:
+                    case 0:
+                        l = s;
+                        u = c;
+                        f = t;
+                        break;
+                    case 1:
+                        l = c;
+                        u = s;
+                        f = t;
+                        break;
+                    case 2:
+                        l = t;
+                        u = s;
+                        f = c;
+                        break;
+                    case 3:
+                        l = t;
+                        u = c;
+                        f = s;
+                        break;
+                    case 4:
+                        l = c;
+                        u = t;
+                        f = s;
+                        break;
+                    case 5:
+                        l = s;
+                        u = t;
+                        f = c;
+                        break;
+                }
+                return [
+                    255 * l,
+                    255 * u,
+                    255 * f
+                ];
+            };
+            s.cmyk.rgb = function(e) {
+                var r = e[0] / 100;
+                var t = e[1] / 100;
+                var n = e[2] / 100;
+                var i = e[3] / 100;
+                var a;
+                var s;
+                var o;
+                a = 1 - Math.min(1, r * (1 - i) + i);
+                s = 1 - Math.min(1, t * (1 - i) + i);
+                o = 1 - Math.min(1, n * (1 - i) + i);
+                return [
+                    255 * a,
+                    255 * s,
+                    255 * o
+                ];
+            };
+            s.xyz.rgb = function(e) {
+                var r = e[0] / 100;
+                var t = e[1] / 100;
+                var n = e[2] / 100;
+                var i;
+                var a;
+                var s;
+                i = 3.2406 * r + -1.5372 * t + -0.4986 * n;
+                a = -0.9689 * r + 1.8758 * t + .0415 * n;
+                s = .0557 * r + -0.204 * t + 1.057 * n;
+                i = i > .0031308 ? 1.055 * Math.pow(i, 1 / 2.4) - .055 : 12.92 * i;
+                a = a > .0031308 ? 1.055 * Math.pow(a, 1 / 2.4) - .055 : 12.92 * a;
+                s = s > .0031308 ? 1.055 * Math.pow(s, 1 / 2.4) - .055 : 12.92 * s;
+                i = Math.min(Math.max(0, i), 1);
+                a = Math.min(Math.max(0, a), 1);
+                s = Math.min(Math.max(0, s), 1);
+                return [
+                    255 * i,
+                    255 * a,
+                    255 * s
+                ];
+            };
+            s.xyz.lab = function(e) {
+                var r = e[0];
+                var t = e[1];
+                var n = e[2];
+                var i;
+                var a;
+                var s;
+                r /= 95.047;
+                t /= 100;
+                n /= 108.883;
+                r = r > .008856 ? Math.pow(r, 1 / 3) : 7.787 * r + 16 / 116;
+                t = t > .008856 ? Math.pow(t, 1 / 3) : 7.787 * t + 16 / 116;
+                n = n > .008856 ? Math.pow(n, 1 / 3) : 7.787 * n + 16 / 116;
+                i = 116 * t - 16;
+                a = 500 * (r - t);
+                s = 200 * (t - n);
+                return [
+                    i,
+                    a,
+                    s
+                ];
+            };
+            s.lab.xyz = function(e) {
+                var r = e[0];
+                var t = e[1];
+                var n = e[2];
+                var i;
+                var a;
+                var s;
+                a = (r + 16) / 116;
+                i = t / 500 + a;
+                s = a - n / 200;
+                var o = Math.pow(a, 3);
+                var c = Math.pow(i, 3);
+                var l = Math.pow(s, 3);
+                a = o > .008856 ? o : (a - 16 / 116) / 7.787;
+                i = c > .008856 ? c : (i - 16 / 116) / 7.787;
+                s = l > .008856 ? l : (s - 16 / 116) / 7.787;
+                i *= 95.047;
+                a *= 100;
+                s *= 108.883;
+                return [
+                    i,
+                    a,
+                    s
+                ];
+            };
+            s.lab.lch = function(e) {
+                var r = e[0];
+                var t = e[1];
+                var n = e[2];
+                var i;
+                var a;
+                var s;
+                i = Math.atan2(n, t);
+                a = 360 * i / 2 / Math.PI;
+                if (a < 0) a += 360;
+                s = Math.sqrt(t * t + n * n);
+                return [
+                    r,
+                    s,
+                    a
+                ];
+            };
+            s.lch.lab = function(e) {
+                var r = e[0];
+                var t = e[1];
+                var n = e[2];
+                var i;
+                var a;
+                var s;
+                s = n / 360 * 2 * Math.PI;
+                i = t * Math.cos(s);
+                a = t * Math.sin(s);
+                return [
+                    r,
+                    i,
+                    a
+                ];
+            };
+            s.rgb.ansi16 = function(e) {
+                var r = e[0];
+                var t = e[1];
+                var n = e[2];
+                var i = 1 in arguments ? arguments[1] : s.rgb.hsv(e)[2];
+                i = Math.round(i / 50);
+                if (0 === i) return 30;
+                var a = 30 + (Math.round(n / 255) << 2 | Math.round(t / 255) << 1 | Math.round(r / 255));
+                if (2 === i) a += 60;
+                return a;
+            };
+            s.hsv.ansi16 = function(e) {
+                return s.rgb.ansi16(s.hsv.rgb(e), e[2]);
+            };
+            s.rgb.ansi256 = function(e) {
+                var r = e[0];
+                var t = e[1];
+                var n = e[2];
+                if (r === t && t === n) {
+                    if (r < 8) return 16;
+                    if (r > 248) return 231;
+                    return Math.round((r - 8) / 247 * 24) + 232;
+                }
+                var i = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(t / 255 * 5) + Math.round(n / 255 * 5);
+                return i;
+            };
+            s.ansi16.rgb = function(e) {
+                var r = e % 10;
+                if (0 === r || 7 === r) {
+                    if (e > 50) r += 3.5;
+                    r = r / 10.5 * 255;
+                    return [
+                        r,
+                        r,
+                        r
+                    ];
+                }
+                var t = (~~(e > 50) + 1) * .5;
+                var n = (1 & r) * t * 255;
+                var i = (r >> 1 & 1) * t * 255;
+                var a = (r >> 2 & 1) * t * 255;
+                return [
+                    n,
+                    i,
+                    a
+                ];
+            };
+            s.ansi256.rgb = function(e) {
+                if (e >= 232) {
+                    var r = (e - 232) * 10 + 8;
+                    return [
+                        r,
+                        r,
+                        r
+                    ];
+                }
+                e -= 16;
+                var t;
+                var n = Math.floor(e / 36) / 5 * 255;
+                var i = Math.floor((t = e % 36) / 6) / 5 * 255;
+                var a = t % 6 / 5 * 255;
+                return [
+                    n,
+                    i,
+                    a
+                ];
+            };
+            s.rgb.hex = function(e) {
+                var r = ((255 & Math.round(e[0])) << 16) + ((255 & Math.round(e[1])) << 8) + (255 & Math.round(e[2]));
+                var t = r.toString(16).toUpperCase();
+                return "000000".substring(t.length) + t;
+            };
+            s.hex.rgb = function(e) {
+                var r = e.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+                if (!r) return [
+                    0,
+                    0,
+                    0
+                ];
+                var t = r[0];
+                if (3 === r[0].length) t = t.split("").map(function(e) {
+                    return e + e;
+                }).join("");
+                var n = parseInt(t, 16);
+                var i = n >> 16 & 255;
+                var a = n >> 8 & 255;
+                var s = 255 & n;
+                return [
+                    i,
+                    a,
+                    s
+                ];
+            };
+            s.rgb.hcg = function(e) {
+                var r = e[0] / 255;
+                var t = e[1] / 255;
+                var n = e[2] / 255;
+                var i = Math.max(Math.max(r, t), n);
+                var a = Math.min(Math.min(r, t), n);
+                var s = i - a;
+                var o;
+                var c;
+                o = s < 1 ? a / (1 - s) : 0;
+                c = s <= 0 ? 0 : i === r ? (t - n) / s % 6 : i === t ? 2 + (n - r) / s : 4 + (r - t) / s + 4;
+                c /= 6;
+                c %= 1;
+                return [
+                    360 * c,
+                    100 * s,
+                    100 * o
+                ];
+            };
+            s.hsl.hcg = function(e) {
+                var r = e[1] / 100;
+                var t = e[2] / 100;
+                var n = 1;
+                var i = 0;
+                n = t < .5 ? 2 * r * t : 2 * r * (1 - t);
+                if (n < 1) i = (t - .5 * n) / (1 - n);
+                return [
+                    e[0],
+                    100 * n,
+                    100 * i
+                ];
+            };
+            s.hsv.hcg = function(e) {
+                var r = e[1] / 100;
+                var t = e[2] / 100;
+                var n = r * t;
+                var i = 0;
+                if (n < 1) i = (t - n) / (1 - n);
+                return [
+                    e[0],
+                    100 * n,
+                    100 * i
+                ];
+            };
+            s.hcg.rgb = function(e) {
+                var r = e[0] / 360;
+                var t = e[1] / 100;
+                var n = e[2] / 100;
+                if (0 === t) return [
+                    255 * n,
+                    255 * n,
+                    255 * n
+                ];
+                var i = [
+                    0,
+                    0,
+                    0
+                ];
+                var a = r % 1 * 6;
+                var s = a % 1;
+                var o = 1 - s;
+                var c = 0;
+                switch(Math.floor(a)){
+                    case 0:
+                        i[0] = 1;
+                        i[1] = s;
+                        i[2] = 0;
+                        break;
+                    case 1:
+                        i[0] = o;
+                        i[1] = 1;
+                        i[2] = 0;
+                        break;
+                    case 2:
+                        i[0] = 0;
+                        i[1] = 1;
+                        i[2] = s;
+                        break;
+                    case 3:
+                        i[0] = 0;
+                        i[1] = o;
+                        i[2] = 1;
+                        break;
+                    case 4:
+                        i[0] = s;
+                        i[1] = 0;
+                        i[2] = 1;
+                        break;
+                    default:
+                        i[0] = 1;
+                        i[1] = 0;
+                        i[2] = o;
+                }
+                c = (1 - t) * n;
+                return [
+                    (t * i[0] + c) * 255,
+                    (t * i[1] + c) * 255,
+                    (t * i[2] + c) * 255
+                ];
+            };
+            s.hcg.hsv = function(e) {
+                var r = e[1] / 100;
+                var t = e[2] / 100;
+                var n = r + t * (1 - r);
+                var i = 0;
+                if (n > 0) i = r / n;
+                return [
+                    e[0],
+                    100 * i,
+                    100 * n
+                ];
+            };
+            s.hcg.hsl = function(e) {
+                var r = e[1] / 100;
+                var t = e[2] / 100;
+                var n = t * (1 - r) + .5 * r;
+                var i = 0;
+                if (n > 0 && n < .5) i = r / (2 * n);
+                else if (n >= .5 && n < 1) i = r / (2 * (1 - n));
+                return [
+                    e[0],
+                    100 * i,
+                    100 * n
+                ];
+            };
+            s.hcg.hwb = function(e) {
+                var r = e[1] / 100;
+                var t = e[2] / 100;
+                var n = r + t * (1 - r);
+                return [
+                    e[0],
+                    (n - r) * 100,
+                    (1 - n) * 100
+                ];
+            };
+            s.hwb.hcg = function(e) {
+                var r = e[1] / 100;
+                var t = e[2] / 100;
+                var n = 1 - t;
+                var i = n - r;
+                var a = 0;
+                if (i < 1) a = (n - i) / (1 - i);
+                return [
+                    e[0],
+                    100 * i,
+                    100 * a
+                ];
+            };
+            s.apple.rgb = function(e) {
+                return [
+                    e[0] / 65535 * 255,
+                    e[1] / 65535 * 255,
+                    e[2] / 65535 * 255
+                ];
+            };
+            s.rgb.apple = function(e) {
+                return [
+                    e[0] / 255 * 65535,
+                    e[1] / 255 * 65535,
+                    e[2] / 255 * 65535
+                ];
+            };
+            s.gray.rgb = function(e) {
+                return [
+                    e[0] / 100 * 255,
+                    e[0] / 100 * 255,
+                    e[0] / 100 * 255
+                ];
+            };
+            s.gray.hsl = s.gray.hsv = function(e) {
+                return [
+                    0,
+                    0,
+                    e[0]
+                ];
+            };
+            s.gray.hwb = function(e) {
+                return [
+                    0,
+                    100,
+                    e[0]
+                ];
+            };
+            s.gray.cmyk = function(e) {
+                return [
+                    0,
+                    0,
+                    0,
+                    e[0]
+                ];
+            };
+            s.gray.lab = function(e) {
+                return [
+                    e[0],
+                    0,
+                    0
+                ];
+            };
+            s.gray.hex = function(e) {
+                var r = 255 & Math.round(e[0] / 100 * 255);
+                var t = (r << 16) + (r << 8) + r;
+                var n = t.toString(16).toUpperCase();
+                return "000000".substring(n.length) + n;
+            };
+            s.rgb.gray = function(e) {
+                var r = (e[0] + e[1] + e[2]) / 3;
+                return [
+                    r / 255 * 100
+                ];
+            };
+        },
+        550: (e, r, t)=>{
+            var n = t(899);
+            var i = t(995);
+            var a = {};
+            var s = Object.keys(n);
+            function wrapRaw(e) {
+                var wrappedFn = function(r) {
+                    if (null == r) return r;
+                    if (arguments.length > 1) r = Array.prototype.slice.call(arguments);
+                    return e(r);
+                };
+                if ("conversion" in e) wrappedFn.conversion = e.conversion;
+                return wrappedFn;
+            }
+            function wrapRounded(e) {
+                var wrappedFn = function(r) {
+                    if (null == r) return r;
+                    if (arguments.length > 1) r = Array.prototype.slice.call(arguments);
+                    var t = e(r);
+                    if ("object" == typeof t) for(var n = t.length, i = 0; i < n; i++)t[i] = Math.round(t[i]);
+                    return t;
+                };
+                if ("conversion" in e) wrappedFn.conversion = e.conversion;
+                return wrappedFn;
+            }
+            s.forEach(function(e) {
+                a[e] = {};
+                Object.defineProperty(a[e], "channels", {
+                    value: n[e].channels
+                });
+                Object.defineProperty(a[e], "labels", {
+                    value: n[e].labels
+                });
+                var r = i(e);
+                var t = Object.keys(r);
+                t.forEach(function(t) {
+                    var n = r[t];
+                    a[e][t] = wrapRounded(n);
+                    a[e][t].raw = wrapRaw(n);
+                });
+            });
+            e.exports = a;
+        },
+        995: (e, r, t)=>{
+            var n = t(899);
+            function buildGraph() {
+                var e = {};
+                var r = Object.keys(n);
+                for(var t = r.length, i = 0; i < t; i++)e[r[i]] = {
+                    distance: -1,
+                    parent: null
+                };
+                return e;
+            }
+            function deriveBFS(e) {
+                var r = buildGraph();
+                var t = [
+                    e
+                ];
+                r[e].distance = 0;
+                while(t.length){
+                    var i = t.pop();
+                    var a = Object.keys(n[i]);
+                    for(var s = a.length, o = 0; o < s; o++){
+                        var c = a[o];
+                        var l = r[c];
+                        if (-1 === l.distance) {
+                            l.distance = r[i].distance + 1;
+                            l.parent = i;
+                            t.unshift(c);
+                        }
+                    }
+                }
+                return r;
+            }
+            function link(e, r) {
+                return function(t) {
+                    return r(e(t));
+                };
+            }
+            function wrapConversion(e, r) {
+                var t = [
+                    r[e].parent,
+                    e
+                ];
+                var i = n[r[e].parent][e];
+                var a = r[e].parent;
+                while(r[a].parent){
+                    t.unshift(r[a].parent);
+                    i = link(n[r[a].parent][a], i);
+                    a = r[a].parent;
+                }
+                i.conversion = t;
+                return i;
+            }
+            e.exports = function(e) {
+                var r = deriveBFS(e);
+                var t = {};
+                var n = Object.keys(r);
+                for(var i = n.length, a = 0; a < i; a++){
+                    var s = n[a];
+                    var o = r[s];
+                    if (null !== o.parent) t[s] = wrapConversion(s, r);
+                }
+                return t;
+            };
+        },
+        130: (e)=>{
+            "use strict";
+            e.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
+                ]
+            };
+        },
+        182: (e, r, t)=>{
+            "use strict";
+            var n = t(23);
+            var i = t(8);
+            var a = function(e, r) {
                 if (!e || e.constructor !== String) {
-                    t = e || {};
+                    r = e || {};
                     e = Error.name;
                 }
-                var r = function ErrorEXError(n) {
+                var t = function ErrorEXError(n) {
                     if (!this) return new ErrorEXError(n);
                     n = n instanceof Error ? n.message : n || this.message;
                     Error.call(this, n);
-                    Error.captureStackTrace(this, r);
+                    Error.captureStackTrace(this, t);
                     this.name = e;
                     Object.defineProperty(this, "message", {
                         configurable: true,
                         enumerable: false,
                         get: function() {
                             var e = n.split(/\r?\n/g);
-                            for(var r in t)if (t.hasOwnProperty(r)) {
-                                var s = t[r];
-                                if ("message" in s) {
-                                    e = s.message(this[r], e) || e;
+                            for(var t in r)if (r.hasOwnProperty(t)) {
+                                var a = r[t];
+                                if ("message" in a) {
+                                    e = a.message(this[t], e) || e;
                                     if (!i(e)) e = [
                                         e
                                     ];
@@ -35,70 +2271,70 @@
                             n = e;
                         }
                     });
-                    var s = null;
-                    var o = Object.getOwnPropertyDescriptor(this, "stack");
-                    var c = o.get;
-                    var a = o.value;
-                    delete o.value;
-                    delete o.writable;
-                    o.set = function(e) {
-                        s = e;
+                    var a = null;
+                    var s = Object.getOwnPropertyDescriptor(this, "stack");
+                    var o = s.get;
+                    var c = s.value;
+                    delete s.value;
+                    delete s.writable;
+                    s.set = function(e) {
+                        a = e;
                     };
-                    o.get = function() {
-                        var e = (s || (c ? c.call(this) : a)).split(/\r?\n+/g);
-                        if (!s) e[0] = this.name + ": " + this.message;
-                        var r = 1;
-                        for(var n in t)if (t.hasOwnProperty(n)) {
-                            var i = t[n];
+                    s.get = function() {
+                        var e = (a || (o ? o.call(this) : c)).split(/\r?\n+/g);
+                        if (!a) e[0] = this.name + ": " + this.message;
+                        var t = 1;
+                        for(var n in r)if (r.hasOwnProperty(n)) {
+                            var i = r[n];
                             if ("line" in i) {
-                                var o = i.line(this[n]);
-                                if (o) e.splice(r++, 0, "    " + o);
+                                var s = i.line(this[n]);
+                                if (s) e.splice(t++, 0, "    " + s);
                             }
                             if ("stack" in i) i.stack(this[n], e);
                         }
                         return e.join("\n");
                     };
-                    Object.defineProperty(this, "stack", o);
+                    Object.defineProperty(this, "stack", s);
                 };
                 if (Object.setPrototypeOf) {
-                    Object.setPrototypeOf(r.prototype, Error.prototype);
-                    Object.setPrototypeOf(r, Error);
-                } else n.inherits(r, Error);
-                return r;
+                    Object.setPrototypeOf(t.prototype, Error.prototype);
+                    Object.setPrototypeOf(t, Error);
+                } else n.inherits(t, Error);
+                return t;
             };
-            s.append = function(e, t) {
+            a.append = function(e, r) {
                 return {
-                    message: function(r, n) {
-                        r = r || t;
-                        if (r) n[0] += " " + e.replace("%s", r.toString());
+                    message: function(t, n) {
+                        t = t || r;
+                        if (t) n[0] += " " + e.replace("%s", t.toString());
                         return n;
                     }
                 };
             };
-            s.line = function(e, t) {
+            a.line = function(e, r) {
                 return {
-                    line: function(r) {
-                        r = r || t;
-                        if (r) return e.replace("%s", r.toString());
+                    line: function(t) {
+                        t = t || r;
+                        if (t) return e.replace("%s", t.toString());
                         return null;
                     }
                 };
             };
-            e.exports = s;
+            e.exports = a;
         },
-        434: (e)=>{
+        767: (e)=>{
             "use strict";
-            var t = /[|\\{}()[\]^$+*?.]/g;
+            var r = /[|\\{}()[\]^$+*?.]/g;
             e.exports = function(e) {
                 if ("string" != typeof e) throw new TypeError("Expected a string");
-                return e.replace(t, "\\$&");
+                return e.replace(r, "\\$&");
             };
         },
-        877: (e, t, r)=>{
+        215: (e, r, t)=>{
             "use strict";
-            const n = r(434);
+            const n = t(767);
             const i = process.platform;
-            const s = {
+            const a = {
                 tick: "✔",
                 cross: "✖",
                 star: "★",
@@ -156,7 +2392,7 @@
                 fiveEighths: "⅝",
                 sevenEighths: "⅞"
             };
-            const o = {
+            const s = {
                 tick: "√",
                 cross: "×",
                 star: "*",
@@ -183,11 +2419,11 @@
                 hamburger: "≡",
                 smiley: "☺",
                 mustache: "┌─┐",
-                heart: s.heart,
-                arrowUp: s.arrowUp,
-                arrowDown: s.arrowDown,
-                arrowLeft: s.arrowLeft,
-                arrowRight: s.arrowRight,
+                heart: a.heart,
+                arrowUp: a.arrowUp,
+                arrowDown: a.arrowDown,
+                arrowLeft: a.arrowLeft,
+                arrowRight: a.arrowRight,
                 radioOn: "(*)",
                 radioOff: "( )",
                 checkboxOn: "[×]",
@@ -214,110 +2450,110 @@
                 fiveEighths: "5/8",
                 sevenEighths: "7/8"
             };
-            if ("linux" === i) s.questionMarkPrefix = "?";
-            const c = "win32" === i ? o : s;
+            if ("linux" === i) a.questionMarkPrefix = "?";
+            const o = "win32" === i ? s : a;
             const fn = (e)=>{
-                if (c === s) return e;
-                Object.keys(s).forEach((t)=>{
-                    if (s[t] === c[t]) return;
-                    e = e.replace(new RegExp(n(s[t]), "g"), c[t]);
+                if (o === a) return e;
+                Object.keys(a).forEach((r)=>{
+                    if (a[r] === o[r]) return;
+                    e = e.replace(new RegExp(n(a[r]), "g"), o[r]);
                 });
                 return e;
             };
-            e.exports = Object.assign(fn, c);
+            e.exports = Object.assign(fn, o);
         },
-        834: (e, t, r)=>{
+        378: (e, r, t)=>{
             "use strict";
-            const n = r(17);
-            const i = r(69);
-            e.exports = (e, t)=>{
-                t = t || {};
-                const r = n.resolve(t.cwd || "");
-                const s = n.parse(r).root;
-                const o = [].concat(e);
+            const n = t(928);
+            const i = t(845);
+            e.exports = (e, r)=>{
+                r = r || {};
+                const t = n.resolve(r.cwd || "");
+                const a = n.parse(t).root;
+                const s = [].concat(e);
                 return new Promise((e)=>{
-                    (function find(t) {
-                        i(o, {
-                            cwd: t
-                        }).then((r)=>{
-                            if (r) e(n.join(t, r));
-                            else if (t === s) e(null);
-                            else find(n.dirname(t));
+                    (function find(r) {
+                        i(s, {
+                            cwd: r
+                        }).then((t)=>{
+                            if (t) e(n.join(r, t));
+                            else if (r === a) e(null);
+                            else find(n.dirname(r));
                         });
-                    })(r);
+                    })(t);
                 });
             };
-            e.exports.sync = (e, t)=>{
-                t = t || {};
-                let r = n.resolve(t.cwd || "");
-                const s = n.parse(r).root;
-                const o = [].concat(e);
+            e.exports.sync = (e, r)=>{
+                r = r || {};
+                let t = n.resolve(r.cwd || "");
+                const a = n.parse(t).root;
+                const s = [].concat(e);
                 while(true){
-                    const e = i.sync(o, {
-                        cwd: r
+                    const e = i.sync(s, {
+                        cwd: t
                     });
-                    if (e) return n.join(r, e);
-                    if (r === s) return null;
-                    r = n.dirname(r);
+                    if (e) return n.join(t, e);
+                    else if (t === a) return null;
+                    t = n.dirname(t);
                 }
             };
         },
-        132: (e)=>{
+        844: (e)=>{
             "use strict";
             e.exports = clone;
-            var t = Object.getPrototypeOf || function(e) {
+            var r = Object.getPrototypeOf || function(e) {
                 return e.__proto__;
             };
             function clone(e) {
                 if (null === e || "object" != typeof e) return e;
-                if (e instanceof Object) var r = {
-                    __proto__: t(e)
+                if (e instanceof Object) var t = {
+                    __proto__: r(e)
                 };
-                else var r = Object.create(null);
-                Object.getOwnPropertyNames(e).forEach(function(t) {
-                    Object.defineProperty(r, t, Object.getOwnPropertyDescriptor(e, t));
+                else var t = Object.create(null);
+                Object.getOwnPropertyNames(e).forEach(function(r) {
+                    Object.defineProperty(t, r, Object.getOwnPropertyDescriptor(e, r));
                 });
-                return r;
+                return t;
             }
         },
-        127: (e, t, r)=>{
-            var n = r(147);
-            var i = r(738);
-            var s = r(876);
-            var o = r(132);
-            var c = r(837);
-            var a;
+        976: (e, r, t)=>{
+            var n = t(896);
+            var i = t(269);
+            var a = t(422);
+            var s = t(844);
+            var o = t(23);
+            var c;
             var l;
             if ("function" == typeof Symbol && "function" == typeof Symbol.for) {
-                a = Symbol.for("graceful-fs.queue");
+                c = Symbol.for("graceful-fs.queue");
                 l = Symbol.for("graceful-fs.previous");
             } else {
-                a = "___graceful-fs.queue";
+                c = "___graceful-fs.queue";
                 l = "___graceful-fs.previous";
             }
             function noop() {}
-            function publishQueue(e, t) {
-                Object.defineProperty(e, a, {
+            function publishQueue(e, r) {
+                Object.defineProperty(e, c, {
                     get: function() {
-                        return t;
+                        return r;
                     }
                 });
             }
-            var f = noop;
-            if (c.debuglog) f = c.debuglog("gfs4");
-            else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) f = function() {
-                var e = c.format.apply(c, arguments);
+            var u = noop;
+            if (o.debuglog) u = o.debuglog("gfs4");
+            else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) u = function() {
+                var e = o.format.apply(o, arguments);
                 e = "GFS4: " + e.split(/\n/).join("\nGFS4: ");
                 console.error(e);
             };
-            if (!n[a]) {
-                var u = global[a] || [];
-                publishQueue(n, u);
+            if (!n[c]) {
+                var f = global[c] || [];
+                publishQueue(n, f);
                 n.close = function(e) {
-                    function close(t, r) {
-                        return e.call(n, t, function(e) {
+                    function close(r, t) {
+                        return e.call(n, r, function(e) {
                             if (!e) resetQueue();
-                            if ("function" == typeof r) r.apply(this, arguments);
+                            if ("function" == typeof t) t.apply(this, arguments);
                         });
                     }
                     Object.defineProperty(close, l, {
@@ -326,7 +2562,7 @@
                     return close;
                 }(n.close);
                 n.closeSync = function(e) {
-                    function closeSync(t) {
+                    function closeSync(r) {
                         e.apply(n, arguments);
                         resetQueue();
                     }
@@ -336,12 +2572,12 @@
                     return closeSync;
                 }(n.closeSync);
                 if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) process.on("exit", function() {
-                    f(n[a]);
-                    r(491).equal(n[a].length, 0);
+                    u(n[c]);
+                    t(613).equal(n[c].length, 0);
                 });
             }
-            if (!global[a]) publishQueue(global, n[a]);
-            e.exports = patch(o(n));
+            if (!global[c]) publishQueue(global, n[c]);
+            e.exports = patch(s(n));
             if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !n.__patched) {
                 e.exports = patch(n);
                 n.__patched = true;
@@ -351,21 +2587,21 @@
                 e.gracefulify = patch;
                 e.createReadStream = createReadStream;
                 e.createWriteStream = createWriteStream;
-                var t = e.readFile;
+                var r = e.readFile;
                 e.readFile = readFile;
-                function readFile(e, r, n) {
-                    if ("function" == typeof r) n = r, r = null;
-                    return go$readFile(e, r, n);
-                    function go$readFile(e, r, n, i) {
-                        return t(e, r, function(t) {
-                            if (t && ("EMFILE" === t.code || "ENFILE" === t.code)) enqueue([
+                function readFile(e, t, n) {
+                    if ("function" == typeof t) n = t, t = null;
+                    return go$readFile(e, t, n);
+                    function go$readFile(e, t, n, i) {
+                        return r(e, t, function(r) {
+                            if (r && ("EMFILE" === r.code || "ENFILE" === r.code)) enqueue([
                                 go$readFile,
                                 [
                                     e,
-                                    r,
+                                    t,
                                     n
                                 ],
-                                t,
+                                r,
                                 i || Date.now(),
                                 Date.now()
                             ]);
@@ -373,23 +2609,23 @@
                         });
                     }
                 }
-                var r = e.writeFile;
+                var t = e.writeFile;
                 e.writeFile = writeFile;
-                function writeFile(e, t, n, i) {
+                function writeFile(e, r, n, i) {
                     if ("function" == typeof n) i = n, n = null;
-                    return go$writeFile(e, t, n, i);
-                    function go$writeFile(e, t, n, i, s) {
-                        return r(e, t, n, function(r) {
-                            if (r && ("EMFILE" === r.code || "ENFILE" === r.code)) enqueue([
+                    return go$writeFile(e, r, n, i);
+                    function go$writeFile(e, r, n, i, a) {
+                        return t(e, r, n, function(t) {
+                            if (t && ("EMFILE" === t.code || "ENFILE" === t.code)) enqueue([
                                 go$writeFile,
                                 [
                                     e,
-                                    t,
+                                    r,
                                     n,
                                     i
                                 ],
-                                r,
-                                s || Date.now(),
+                                t,
+                                a || Date.now(),
                                 Date.now()
                             ]);
                             else if ("function" == typeof i) i.apply(this, arguments);
@@ -398,46 +2634,46 @@
                 }
                 var n = e.appendFile;
                 if (n) e.appendFile = appendFile;
-                function appendFile(e, t, r, i) {
-                    if ("function" == typeof r) i = r, r = null;
-                    return go$appendFile(e, t, r, i);
-                    function go$appendFile(e, t, r, i, s) {
-                        return n(e, t, r, function(n) {
+                function appendFile(e, r, t, i) {
+                    if ("function" == typeof t) i = t, t = null;
+                    return go$appendFile(e, r, t, i);
+                    function go$appendFile(e, r, t, i, a) {
+                        return n(e, r, t, function(n) {
                             if (n && ("EMFILE" === n.code || "ENFILE" === n.code)) enqueue([
                                 go$appendFile,
                                 [
                                     e,
-                                    t,
                                     r,
+                                    t,
                                     i
                                 ],
                                 n,
-                                s || Date.now(),
+                                a || Date.now(),
                                 Date.now()
                             ]);
                             else if ("function" == typeof i) i.apply(this, arguments);
                         });
                     }
                 }
-                var o = e.copyFile;
-                if (o) e.copyFile = copyFile;
-                function copyFile(e, t, r, n) {
-                    if ("function" == typeof r) {
-                        n = r;
-                        r = 0;
+                var s = e.copyFile;
+                if (s) e.copyFile = copyFile;
+                function copyFile(e, r, t, n) {
+                    if ("function" == typeof t) {
+                        n = t;
+                        t = 0;
                     }
-                    return go$copyFile(e, t, r, n);
-                    function go$copyFile(e, t, r, n, i) {
-                        return o(e, t, r, function(s) {
-                            if (s && ("EMFILE" === s.code || "ENFILE" === s.code)) enqueue([
+                    return go$copyFile(e, r, t, n);
+                    function go$copyFile(e, r, t, n, i) {
+                        return s(e, r, t, function(a) {
+                            if (a && ("EMFILE" === a.code || "ENFILE" === a.code)) enqueue([
                                 go$copyFile,
                                 [
                                     e,
-                                    t,
                                     r,
+                                    t,
                                     n
                                 ],
-                                s,
+                                a,
                                 i || Date.now(),
                                 Date.now()
                             ]);
@@ -445,50 +2681,50 @@
                         });
                     }
                 }
-                var c = e.readdir;
+                var o = e.readdir;
                 e.readdir = readdir;
-                var a = /^v[0-5]\./;
-                function readdir(e, t, r) {
-                    if ("function" == typeof t) r = t, t = null;
-                    var n = a.test(process.version) ? function(e, t, r, n) {
-                        return c(e, fs$readdirCallback(e, t, r, n));
-                    } : function(e, t, r, n) {
-                        return c(e, t, fs$readdirCallback(e, t, r, n));
+                var c = /^v[0-5]\./;
+                function readdir(e, r, t) {
+                    if ("function" == typeof r) t = r, r = null;
+                    var n = c.test(process.version) ? function(e, r, t, n) {
+                        return o(e, fs$readdirCallback(e, r, t, n));
+                    } : function(e, r, t, n) {
+                        return o(e, r, fs$readdirCallback(e, r, t, n));
                     };
-                    return n(e, t, r);
-                    function fs$readdirCallback(e, t, r, i) {
-                        return function(s, o) {
-                            if (s && ("EMFILE" === s.code || "ENFILE" === s.code)) enqueue([
+                    return n(e, r, t);
+                    function fs$readdirCallback(e, r, t, i) {
+                        return function(a, s) {
+                            if (a && ("EMFILE" === a.code || "ENFILE" === a.code)) enqueue([
                                 n,
                                 [
                                     e,
-                                    t,
-                                    r
+                                    r,
+                                    t
                                 ],
-                                s,
+                                a,
                                 i || Date.now(),
                                 Date.now()
                             ]);
                             else {
-                                if (o && o.sort) o.sort();
-                                if ("function" == typeof r) r.call(this, s, o);
+                                if (s && s.sort) s.sort();
+                                if ("function" == typeof t) t.call(this, a, s);
                             }
                         };
                     }
                 }
                 if ("v0.8" === process.version.substr(0, 4)) {
-                    var l = s(e);
+                    var l = a(e);
                     ReadStream = l.ReadStream;
                     WriteStream = l.WriteStream;
                 }
-                var f = e.ReadStream;
-                if (f) {
-                    ReadStream.prototype = Object.create(f.prototype);
+                var u = e.ReadStream;
+                if (u) {
+                    ReadStream.prototype = Object.create(u.prototype);
                     ReadStream.prototype.open = ReadStream$open;
                 }
-                var u = e.WriteStream;
-                if (u) {
-                    WriteStream.prototype = Object.create(u.prototype);
+                var f = e.WriteStream;
+                if (f) {
+                    WriteStream.prototype = Object.create(f.prototype);
                     WriteStream.prototype.open = WriteStream$open;
                 }
                 Object.defineProperty(e, "ReadStream", {
@@ -533,61 +2769,61 @@
                     enumerable: true,
                     configurable: true
                 });
-                function ReadStream(e, t) {
-                    if (this instanceof ReadStream) return f.apply(this, arguments), this;
-                    return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
+                function ReadStream(e, r) {
+                    if (this instanceof ReadStream) return u.apply(this, arguments), this;
+                    else return ReadStream.apply(Object.create(ReadStream.prototype), arguments);
                 }
                 function ReadStream$open() {
                     var e = this;
-                    open(e.path, e.flags, e.mode, function(t, r) {
-                        if (t) {
+                    open(e.path, e.flags, e.mode, function(r, t) {
+                        if (r) {
                             if (e.autoClose) e.destroy();
-                            e.emit("error", t);
+                            e.emit("error", r);
                         } else {
-                            e.fd = r;
-                            e.emit("open", r);
+                            e.fd = t;
+                            e.emit("open", t);
                             e.read();
                         }
                     });
                 }
-                function WriteStream(e, t) {
-                    if (this instanceof WriteStream) return u.apply(this, arguments), this;
-                    return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
+                function WriteStream(e, r) {
+                    if (this instanceof WriteStream) return f.apply(this, arguments), this;
+                    else return WriteStream.apply(Object.create(WriteStream.prototype), arguments);
                 }
                 function WriteStream$open() {
                     var e = this;
-                    open(e.path, e.flags, e.mode, function(t, r) {
-                        if (t) {
+                    open(e.path, e.flags, e.mode, function(r, t) {
+                        if (r) {
                             e.destroy();
-                            e.emit("error", t);
+                            e.emit("error", r);
                         } else {
-                            e.fd = r;
-                            e.emit("open", r);
+                            e.fd = t;
+                            e.emit("open", t);
                         }
                     });
                 }
-                function createReadStream(t, r) {
-                    return new e.ReadStream(t, r);
+                function createReadStream(r, t) {
+                    return new e.ReadStream(r, t);
                 }
-                function createWriteStream(t, r) {
-                    return new e.WriteStream(t, r);
+                function createWriteStream(r, t) {
+                    return new e.WriteStream(r, t);
                 }
-                var d = e.open;
+                var g = e.open;
                 e.open = open;
-                function open(e, t, r, n) {
-                    if ("function" == typeof r) n = r, r = null;
-                    return go$open(e, t, r, n);
-                    function go$open(e, t, r, n, i) {
-                        return d(e, t, r, function(s, o) {
-                            if (s && ("EMFILE" === s.code || "ENFILE" === s.code)) enqueue([
+                function open(e, r, t, n) {
+                    if ("function" == typeof t) n = t, t = null;
+                    return go$open(e, r, t, n);
+                    function go$open(e, r, t, n, i) {
+                        return g(e, r, t, function(a, s) {
+                            if (a && ("EMFILE" === a.code || "ENFILE" === a.code)) enqueue([
                                 go$open,
                                 [
                                     e,
-                                    t,
                                     r,
+                                    t,
                                     n
                                 ],
-                                s,
+                                a,
                                 i || Date.now(),
                                 Date.now()
                             ]);
@@ -598,74 +2834,74 @@
                 return e;
             }
             function enqueue(e) {
-                f("ENQUEUE", e[0].name, e[1]);
-                n[a].push(e);
+                u("ENQUEUE", e[0].name, e[1]);
+                n[c].push(e);
                 retry();
             }
             var h;
             function resetQueue() {
                 var e = Date.now();
-                for(var t = 0; t < n[a].length; ++t)if (n[a][t].length > 2) {
-                    n[a][t][3] = e;
-                    n[a][t][4] = e;
+                for(var r = 0; r < n[c].length; ++r)if (n[c][r].length > 2) {
+                    n[c][r][3] = e;
+                    n[c][r][4] = e;
                 }
                 retry();
             }
             function retry() {
                 clearTimeout(h);
                 h = void 0;
-                if (0 === n[a].length) return;
-                var e = n[a].shift();
-                var t = e[0];
-                var r = e[1];
+                if (0 === n[c].length) return;
+                var e = n[c].shift();
+                var r = e[0];
+                var t = e[1];
                 var i = e[2];
-                var s = e[3];
-                var o = e[4];
-                if (void 0 === s) {
-                    f("RETRY", t.name, r);
-                    t.apply(null, r);
-                } else if (Date.now() - s >= 6e4) {
-                    f("TIMEOUT", t.name, r);
-                    var c = r.pop();
-                    if ("function" == typeof c) c.call(null, i);
+                var a = e[3];
+                var s = e[4];
+                if (void 0 === a) {
+                    u("RETRY", r.name, t);
+                    r.apply(null, t);
+                } else if (Date.now() - a >= 6e4) {
+                    u("TIMEOUT", r.name, t);
+                    var o = t.pop();
+                    if ("function" == typeof o) o.call(null, i);
                 } else {
-                    var l = Date.now() - o;
-                    var u = Math.max(o - s, 1);
-                    var p = Math.min(1.2 * u, 100);
+                    var l = Date.now() - s;
+                    var f = Math.max(s - a, 1);
+                    var p = Math.min(1.2 * f, 100);
                     if (l >= p) {
-                        f("RETRY", t.name, r);
-                        t.apply(null, r.concat([
-                            s
+                        u("RETRY", r.name, t);
+                        r.apply(null, t.concat([
+                            a
                         ]));
-                    } else n[a].push(e);
+                    } else n[c].push(e);
                 }
                 if (void 0 === h) h = setTimeout(retry, 0);
             }
         },
-        876: (e, t, r)=>{
-            var n = r(781).Stream;
+        422: (e, r, t)=>{
+            var n = t(203).Stream;
             e.exports = legacy;
             function legacy(e) {
                 return {
                     ReadStream: ReadStream,
                     WriteStream: WriteStream
                 };
-                function ReadStream(t, r) {
-                    if (!(this instanceof ReadStream)) return new ReadStream(t, r);
+                function ReadStream(r, t) {
+                    if (!(this instanceof ReadStream)) return new ReadStream(r, t);
                     n.call(this);
                     var i = this;
-                    this.path = t;
+                    this.path = r;
                     this.fd = null;
                     this.readable = true;
                     this.paused = false;
                     this.flags = "r";
                     this.mode = 438;
                     this.bufferSize = 65536;
-                    r = r || {};
-                    var s = Object.keys(r);
-                    for(var o = 0, c = s.length; o < c; o++){
-                        var a = s[o];
-                        this[a] = r[a];
+                    t = t || {};
+                    var a = Object.keys(t);
+                    for(var s = 0, o = a.length; s < o; s++){
+                        var c = a[s];
+                        this[c] = t[c];
                     }
                     if (this.encoding) this.setEncoding(this.encoding);
                     if (void 0 !== this.start) {
@@ -678,32 +2914,32 @@
                     if (null !== this.fd) return void process.nextTick(function() {
                         i._read();
                     });
-                    e.open(this.path, this.flags, this.mode, function(e, t) {
+                    e.open(this.path, this.flags, this.mode, function(e, r) {
                         if (e) {
                             i.emit("error", e);
                             i.readable = false;
                             return;
                         }
-                        i.fd = t;
-                        i.emit("open", t);
+                        i.fd = r;
+                        i.emit("open", r);
                         i._read();
                     });
                 }
-                function WriteStream(t, r) {
-                    if (!(this instanceof WriteStream)) return new WriteStream(t, r);
+                function WriteStream(r, t) {
+                    if (!(this instanceof WriteStream)) return new WriteStream(r, t);
                     n.call(this);
-                    this.path = t;
+                    this.path = r;
                     this.fd = null;
                     this.writable = true;
                     this.flags = "w";
                     this.encoding = "binary";
                     this.mode = 438;
                     this.bytesWritten = 0;
-                    r = r || {};
-                    var i = Object.keys(r);
-                    for(var s = 0, o = i.length; s < o; s++){
-                        var c = i[s];
-                        this[c] = r[c];
+                    t = t || {};
+                    var i = Object.keys(t);
+                    for(var a = 0, s = i.length; a < s; a++){
+                        var o = i[a];
+                        this[o] = t[o];
                     }
                     if (void 0 !== this.start) {
                         if ("number" != typeof this.start) throw TypeError("start must be a Number");
@@ -726,25 +2962,25 @@
                 }
             }
         },
-        738: (e, t, r)=>{
-            var n = r(57);
+        269: (e, r, t)=>{
+            var n = t(140);
             var i = process.cwd;
-            var s = null;
-            var o = process.env.GRACEFUL_FS_PLATFORM || process.platform;
+            var a = null;
+            var s = process.env.GRACEFUL_FS_PLATFORM || process.platform;
             process.cwd = function() {
-                if (!s) s = i.call(process);
-                return s;
+                if (!a) a = i.call(process);
+                return a;
             };
             try {
                 process.cwd();
             } catch (e) {}
             if ("function" == typeof process.chdir) {
-                var c = process.chdir;
+                var o = process.chdir;
                 process.chdir = function(e) {
-                    s = null;
-                    c.call(process, e);
+                    a = null;
+                    o.call(process, e);
                 };
-                if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, c);
+                if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, o);
             }
             e.exports = patch;
             function patch(e) {
@@ -769,64 +3005,64 @@
                 e.fstatSync = statFixSync(e.fstatSync);
                 e.lstatSync = statFixSync(e.lstatSync);
                 if (e.chmod && !e.lchmod) {
-                    e.lchmod = function(e, t, r) {
-                        if (r) process.nextTick(r);
+                    e.lchmod = function(e, r, t) {
+                        if (t) process.nextTick(t);
                     };
                     e.lchmodSync = function() {};
                 }
                 if (e.chown && !e.lchown) {
-                    e.lchown = function(e, t, r, n) {
+                    e.lchown = function(e, r, t, n) {
                         if (n) process.nextTick(n);
                     };
                     e.lchownSync = function() {};
                 }
-                if ("win32" === o) e.rename = "function" != typeof e.rename ? e.rename : function(t) {
-                    function rename(r, n, i) {
-                        var s = Date.now();
-                        var o = 0;
-                        t(r, n, function CB(c) {
-                            if (c && ("EACCES" === c.code || "EPERM" === c.code) && Date.now() - s < 6e4) {
+                if ("win32" === s) e.rename = "function" != typeof e.rename ? e.rename : function(r) {
+                    function rename(t, n, i) {
+                        var a = Date.now();
+                        var s = 0;
+                        r(t, n, function CB(o) {
+                            if (o && ("EACCES" === o.code || "EPERM" === o.code || "EBUSY" === o.code) && Date.now() - a < 6e4) {
                                 setTimeout(function() {
-                                    e.stat(n, function(e, s) {
-                                        if (e && "ENOENT" === e.code) t(r, n, CB);
-                                        else i(c);
+                                    e.stat(n, function(e, a) {
+                                        if (e && "ENOENT" === e.code) r(t, n, CB);
+                                        else i(o);
                                     });
-                                }, o);
-                                if (o < 100) o += 10;
+                                }, s);
+                                if (s < 100) s += 10;
                                 return;
                             }
-                            if (i) i(c);
+                            if (i) i(o);
                         });
                     }
-                    if (Object.setPrototypeOf) Object.setPrototypeOf(rename, t);
+                    if (Object.setPrototypeOf) Object.setPrototypeOf(rename, r);
                     return rename;
                 }(e.rename);
-                e.read = "function" != typeof e.read ? e.read : function(t) {
-                    function read(r, n, i, s, o, c) {
-                        var a;
-                        if (c && "function" == typeof c) {
+                e.read = "function" != typeof e.read ? e.read : function(r) {
+                    function read(t, n, i, a, s, o) {
+                        var c;
+                        if (o && "function" == typeof o) {
                             var l = 0;
-                            a = function(f, u, h) {
-                                if (f && "EAGAIN" === f.code && l < 10) {
+                            c = function(u, f, h) {
+                                if (u && "EAGAIN" === u.code && l < 10) {
                                     l++;
-                                    return t.call(e, r, n, i, s, o, a);
+                                    return r.call(e, t, n, i, a, s, c);
                                 }
-                                c.apply(this, arguments);
+                                o.apply(this, arguments);
                             };
                         }
-                        return t.call(e, r, n, i, s, o, a);
+                        return r.call(e, t, n, i, a, s, c);
                     }
-                    if (Object.setPrototypeOf) Object.setPrototypeOf(read, t);
+                    if (Object.setPrototypeOf) Object.setPrototypeOf(read, r);
                     return read;
                 }(e.read);
-                e.readSync = "function" != typeof e.readSync ? e.readSync : function(t) {
-                    return function(r, n, i, s, o) {
-                        var c = 0;
+                e.readSync = "function" != typeof e.readSync ? e.readSync : function(r) {
+                    return function(t, n, i, a, s) {
+                        var o = 0;
                         while(true)try {
-                            return t.call(e, r, n, i, s, o);
+                            return r.call(e, t, n, i, a, s);
                         } catch (e) {
-                            if ("EAGAIN" === e.code && c < 10) {
-                                c++;
+                            if ("EAGAIN" === e.code && o < 10) {
+                                o++;
                                 continue;
                             }
                             throw e;
@@ -834,131 +3070,131 @@
                     };
                 }(e.readSync);
                 function patchLchmod(e) {
-                    e.lchmod = function(t, r, i) {
-                        e.open(t, n.O_WRONLY | n.O_SYMLINK, r, function(t, n) {
-                            if (t) {
-                                if (i) i(t);
+                    e.lchmod = function(r, t, i) {
+                        e.open(r, n.O_WRONLY | n.O_SYMLINK, t, function(r, n) {
+                            if (r) {
+                                if (i) i(r);
                                 return;
                             }
-                            e.fchmod(n, r, function(t) {
+                            e.fchmod(n, t, function(r) {
                                 e.close(n, function(e) {
-                                    if (i) i(t || e);
+                                    if (i) i(r || e);
                                 });
                             });
                         });
                     };
-                    e.lchmodSync = function(t, r) {
-                        var i = e.openSync(t, n.O_WRONLY | n.O_SYMLINK, r);
-                        var s = true;
-                        var o;
+                    e.lchmodSync = function(r, t) {
+                        var i = e.openSync(r, n.O_WRONLY | n.O_SYMLINK, t);
+                        var a = true;
+                        var s;
                         try {
-                            o = e.fchmodSync(i, r);
-                            s = false;
+                            s = e.fchmodSync(i, t);
+                            a = false;
                         } finally{
-                            if (s) try {
+                            if (a) try {
                                 e.closeSync(i);
                             } catch (e) {}
                             else e.closeSync(i);
                         }
-                        return o;
+                        return s;
                     };
                 }
                 function patchLutimes(e) {
                     if (n.hasOwnProperty("O_SYMLINK") && e.futimes) {
-                        e.lutimes = function(t, r, i, s) {
-                            e.open(t, n.O_SYMLINK, function(t, n) {
-                                if (t) {
-                                    if (s) s(t);
+                        e.lutimes = function(r, t, i, a) {
+                            e.open(r, n.O_SYMLINK, function(r, n) {
+                                if (r) {
+                                    if (a) a(r);
                                     return;
                                 }
-                                e.futimes(n, r, i, function(t) {
+                                e.futimes(n, t, i, function(r) {
                                     e.close(n, function(e) {
-                                        if (s) s(t || e);
+                                        if (a) a(r || e);
                                     });
                                 });
                             });
                         };
-                        e.lutimesSync = function(t, r, i) {
-                            var s = e.openSync(t, n.O_SYMLINK);
-                            var o;
-                            var c = true;
+                        e.lutimesSync = function(r, t, i) {
+                            var a = e.openSync(r, n.O_SYMLINK);
+                            var s;
+                            var o = true;
                             try {
-                                o = e.futimesSync(s, r, i);
-                                c = false;
+                                s = e.futimesSync(a, t, i);
+                                o = false;
                             } finally{
-                                if (c) try {
-                                    e.closeSync(s);
+                                if (o) try {
+                                    e.closeSync(a);
                                 } catch (e) {}
-                                else e.closeSync(s);
+                                else e.closeSync(a);
                             }
-                            return o;
+                            return s;
                         };
                     } else if (e.futimes) {
-                        e.lutimes = function(e, t, r, n) {
+                        e.lutimes = function(e, r, t, n) {
                             if (n) process.nextTick(n);
                         };
                         e.lutimesSync = function() {};
                     }
                 }
-                function chmodFix(t) {
-                    if (!t) return t;
-                    return function(r, n, i) {
-                        return t.call(e, r, n, function(e) {
+                function chmodFix(r) {
+                    if (!r) return r;
+                    return function(t, n, i) {
+                        return r.call(e, t, n, function(e) {
                             if (chownErOk(e)) e = null;
                             if (i) i.apply(this, arguments);
                         });
                     };
                 }
-                function chmodFixSync(t) {
-                    if (!t) return t;
-                    return function(r, n) {
+                function chmodFixSync(r) {
+                    if (!r) return r;
+                    return function(t, n) {
                         try {
-                            return t.call(e, r, n);
+                            return r.call(e, t, n);
                         } catch (e) {
                             if (!chownErOk(e)) throw e;
                         }
                     };
                 }
-                function chownFix(t) {
-                    if (!t) return t;
-                    return function(r, n, i, s) {
-                        return t.call(e, r, n, i, function(e) {
+                function chownFix(r) {
+                    if (!r) return r;
+                    return function(t, n, i, a) {
+                        return r.call(e, t, n, i, function(e) {
                             if (chownErOk(e)) e = null;
-                            if (s) s.apply(this, arguments);
+                            if (a) a.apply(this, arguments);
                         });
                     };
                 }
-                function chownFixSync(t) {
-                    if (!t) return t;
-                    return function(r, n, i) {
+                function chownFixSync(r) {
+                    if (!r) return r;
+                    return function(t, n, i) {
                         try {
-                            return t.call(e, r, n, i);
+                            return r.call(e, t, n, i);
                         } catch (e) {
                             if (!chownErOk(e)) throw e;
                         }
                     };
                 }
-                function statFix(t) {
-                    if (!t) return t;
-                    return function(r, n, i) {
+                function statFix(r) {
+                    if (!r) return r;
+                    return function(t, n, i) {
                         if ("function" == typeof n) {
                             i = n;
                             n = null;
                         }
-                        function callback(e, t) {
-                            if (t) {
-                                if (t.uid < 0) t.uid += 4294967296;
-                                if (t.gid < 0) t.gid += 4294967296;
+                        function callback(e, r) {
+                            if (r) {
+                                if (r.uid < 0) r.uid += 4294967296;
+                                if (r.gid < 0) r.gid += 4294967296;
                             }
                             if (i) i.apply(this, arguments);
                         }
-                        return n ? t.call(e, r, n, callback) : t.call(e, r, callback);
+                        return n ? r.call(e, t, n, callback) : r.call(e, t, callback);
                     };
                 }
-                function statFixSync(t) {
-                    if (!t) return t;
-                    return function(r, n) {
-                        var i = n ? t.call(e, r, n) : t.call(e, r);
+                function statFixSync(r) {
+                    if (!r) return r;
+                    return function(t, n) {
+                        var i = n ? r.call(e, t, n) : r.call(e, t);
                         if (i) {
                             if (i.uid < 0) i.uid += 4294967296;
                             if (i.gid < 0) i.gid += 4294967296;
@@ -969,104 +3205,114 @@
                 function chownErOk(e) {
                     if (!e) return true;
                     if ("ENOSYS" === e.code) return true;
-                    var t = !process.getuid || 0 !== process.getuid();
-                    if (t) {
+                    var r = !process.getuid || 0 !== process.getuid();
+                    if (r) {
                         if ("EINVAL" === e.code || "EPERM" === e.code) return true;
                     }
                     return false;
                 }
             }
         },
-        589: (e)=>{
+        254: (e)=>{
+            "use strict";
+            e.exports = (e, r)=>{
+                r = r || process.argv;
+                const t = e.startsWith("-") ? "" : 1 === e.length ? "-" : "--";
+                const n = r.indexOf(t + e);
+                const i = r.indexOf("--");
+                return -1 !== n && (-1 === i ? true : n < i);
+            };
+        },
+        8: (e)=>{
             "use strict";
             e.exports = function(e) {
                 if (!e) return false;
                 return e instanceof Array || Array.isArray(e) || e.length >= 0 && e.splice instanceof Function;
             };
         },
-        9: (e)=>{
+        926: (e)=>{
             "use strict";
             e.exports = parseJson;
-            function parseJson(e, t, r) {
-                r = r || 20;
+            function parseJson(e, r, t) {
+                t = t || 20;
                 try {
-                    return JSON.parse(e, t);
-                } catch (t) {
+                    return JSON.parse(e, r);
+                } catch (r) {
                     if ("string" != typeof e) {
-                        const t = Array.isArray(e) && 0 === e.length;
-                        const r = "Cannot parse " + (t ? "an empty array" : String(e));
-                        throw new TypeError(r);
+                        const r = Array.isArray(e) && 0 === e.length;
+                        const t = "Cannot parse " + (r ? "an empty array" : String(e));
+                        throw new TypeError(t);
                     }
-                    const n = t.message.match(/^Unexpected token.*position\s+(\d+)/i);
-                    const i = n ? +n[1] : t.message.match(/^Unexpected end of JSON.*/i) ? e.length - 1 : null;
+                    const n = r.message.match(/^Unexpected token.*position\s+(\d+)/i);
+                    const i = n ? +n[1] : r.message.match(/^Unexpected end of JSON.*/i) ? e.length - 1 : null;
                     if (null != i) {
-                        const n = i <= r ? 0 : i - r;
-                        const s = i + r >= e.length ? e.length : i + r;
-                        t.message += ` while parsing near '${0 === n ? "" : "..."}${e.slice(n, s)}${s === e.length ? "" : "..."}'`;
-                    } else t.message += ` while parsing '${e.slice(0, 2 * r)}'`;
-                    throw t;
+                        const n = i <= t ? 0 : i - t;
+                        const a = i + t >= e.length ? e.length : i + t;
+                        r.message += ` while parsing near '${0 === n ? "" : "..."}${e.slice(n, a)}${a === e.length ? "" : "..."}'`;
+                    } else r.message += ` while parsing '${e.slice(0, 2 * t)}'`;
+                    throw r;
                 }
             }
         },
-        324: (e, t, r)=>{
+        903: (e, r, t)=>{
             "use strict";
-            const n = r(17);
-            const i = r(127);
-            const s = r(308);
-            const o = r(264);
-            const c = r(119);
-            const parse = (e, t)=>o(s(e), n.relative(".", t));
-            e.exports = (e)=>c(i.readFile)(e, "utf8").then((t)=>parse(t, e));
+            const n = t(928);
+            const i = t(976);
+            const a = t(878);
+            const s = t(775);
+            const o = t(602);
+            const parse = (e, r)=>s(a(e), n.relative(".", r));
+            e.exports = (e)=>o(i.readFile)(e, "utf8").then((r)=>parse(r, e));
             e.exports.sync = (e)=>parse(i.readFileSync(e, "utf8"), e);
         },
-        69: (e, t, r)=>{
+        845: (e, r, t)=>{
             "use strict";
-            const n = r(17);
-            const i = r(383);
-            const s = r(367);
-            e.exports = (e, t)=>{
-                t = Object.assign({
+            const n = t(928);
+            const i = t(728);
+            const a = t(397);
+            e.exports = (e, r)=>{
+                r = Object.assign({
                     cwd: process.cwd()
-                }, t);
-                return s(e, (e)=>i(n.resolve(t.cwd, e)), t);
+                }, r);
+                return a(e, (e)=>i(n.resolve(r.cwd, e)), r);
             };
-            e.exports.sync = (e, t)=>{
-                t = Object.assign({
+            e.exports.sync = (e, r)=>{
+                r = Object.assign({
                     cwd: process.cwd()
-                }, t);
-                for (const r of e)if (i.sync(n.resolve(t.cwd, r))) return r;
+                }, r);
+                for (const t of e)if (i.sync(n.resolve(r.cwd, t))) return t;
             };
         },
-        273: (e, t, r)=>{
+        801: (e, r, t)=>{
             "use strict";
-            const n = r(965);
+            const n = t(822);
             e.exports = (e)=>{
                 if (e < 1) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-                const t = [];
-                let r = 0;
+                const r = [];
+                let t = 0;
                 const next = ()=>{
-                    r--;
-                    if (t.length > 0) t.shift()();
+                    t--;
+                    if (r.length > 0) r.shift()();
                 };
-                return (i)=>new Promise((s, o)=>{
+                return (i)=>new Promise((a, s)=>{
                         const run = ()=>{
-                            r++;
+                            t++;
                             n(i).then((e)=>{
-                                s(e);
+                                a(e);
                                 next();
                             }, (e)=>{
-                                o(e);
+                                s(e);
                                 next();
                             });
                         };
-                        if (r < e) run();
-                        else t.push(run);
+                        if (t < e) run();
+                        else r.push(run);
                     });
             };
         },
-        367: (e, t, r)=>{
+        397: (e, r, t)=>{
             "use strict";
-            const n = r(273);
+            const n = t(801);
             class EndError extends Error {
                 constructor(e){
                     super();
@@ -1074,59 +3320,59 @@
                 }
             }
             const finder = (e)=>Promise.all(e).then((e)=>true === e[1] && Promise.reject(new EndError(e[0])));
-            e.exports = (e, t, r)=>{
-                r = Object.assign({
+            e.exports = (e, r, t)=>{
+                t = Object.assign({
                     concurrency: 1 / 0,
                     preserveOrder: true
-                }, r);
-                const i = n(r.concurrency);
-                const s = Array.from(e).map((e)=>[
+                }, t);
+                const i = n(t.concurrency);
+                const a = Array.from(e).map((e)=>[
                         e,
-                        i(()=>Promise.resolve(e).then(t))
+                        i(()=>Promise.resolve(e).then(r))
                     ]);
-                const o = n(r.preserveOrder ? 1 : 1 / 0);
-                return Promise.all(s.map((e)=>o(()=>finder(e)))).then(()=>{}).catch((e)=>e instanceof EndError ? e.value : Promise.reject(e));
+                const s = n(t.preserveOrder ? 1 : 1 / 0);
+                return Promise.all(a.map((e)=>s(()=>finder(e)))).then(()=>{}).catch((e)=>e instanceof EndError ? e.value : Promise.reject(e));
             };
         },
-        965: (e)=>{
+        822: (e)=>{
             "use strict";
-            e.exports = (e)=>new Promise((t)=>{
-                    t(e());
+            e.exports = (e)=>new Promise((r)=>{
+                    r(e());
                 });
         },
-        264: (e, t, r)=>{
+        775: (e, r, t)=>{
             "use strict";
-            const n = r(305);
-            const i = r(9);
-            const s = n("JSONError", {
+            const n = t(182);
+            const i = t(926);
+            const a = n("JSONError", {
                 fileName: n.append("in %s")
             });
-            e.exports = (e, t, r)=>{
-                if ("string" == typeof t) {
-                    r = t;
-                    t = null;
+            e.exports = (e, r, t)=>{
+                if ("string" == typeof r) {
+                    t = r;
+                    r = null;
                 }
                 try {
                     try {
-                        return JSON.parse(e, t);
-                    } catch (r) {
-                        i(e, t);
-                        throw r;
+                        return JSON.parse(e, r);
+                    } catch (t) {
+                        i(e, r);
+                        throw t;
                     }
                 } catch (e) {
                     e.message = e.message.replace(/\n/g, "");
-                    const t = new s(e);
-                    if (r) t.fileName = r;
-                    throw t;
+                    const r = new a(e);
+                    if (t) r.fileName = t;
+                    throw r;
                 }
             };
         },
-        383: (e, t, r)=>{
+        728: (e, r, t)=>{
             "use strict";
-            const n = r(147);
-            e.exports = (e)=>new Promise((t)=>{
+            const n = t(896);
+            e.exports = (e)=>new Promise((r)=>{
                     n.access(e, (e)=>{
-                        t(!e);
+                        r(!e);
                     });
                 });
             e.exports.sync = (e)=>{
@@ -1138,128 +3384,128 @@
                 }
             };
         },
-        119: (e)=>{
+        602: (e)=>{
             "use strict";
-            const processFn = (e, t)=>function() {
-                    const r = t.promiseModule;
+            const processFn = (e, r)=>function() {
+                    const t = r.promiseModule;
                     const n = new Array(arguments.length);
                     for(let e = 0; e < arguments.length; e++)n[e] = arguments[e];
-                    return new r((r, i)=>{
-                        if (t.errorFirst) n.push(function(e, n) {
-                            if (t.multiArgs) {
-                                const t = new Array(arguments.length - 1);
-                                for(let e = 1; e < arguments.length; e++)t[e - 1] = arguments[e];
+                    return new t((t, i)=>{
+                        if (r.errorFirst) n.push(function(e, n) {
+                            if (r.multiArgs) {
+                                const r = new Array(arguments.length - 1);
+                                for(let e = 1; e < arguments.length; e++)r[e - 1] = arguments[e];
                                 if (e) {
-                                    t.unshift(e);
-                                    i(t);
-                                } else r(t);
+                                    r.unshift(e);
+                                    i(r);
+                                } else t(r);
                             } else if (e) i(e);
-                            else r(n);
+                            else t(n);
                         });
                         else n.push(function(e) {
-                            if (t.multiArgs) {
+                            if (r.multiArgs) {
                                 const e = new Array(arguments.length - 1);
-                                for(let t = 0; t < arguments.length; t++)e[t] = arguments[t];
-                                r(e);
-                            } else r(e);
+                                for(let r = 0; r < arguments.length; r++)e[r] = arguments[r];
+                                t(e);
+                            } else t(e);
                         });
                         e.apply(this, n);
                     });
                 };
-            e.exports = (e, t)=>{
-                t = Object.assign({
+            e.exports = (e, r)=>{
+                r = Object.assign({
                     exclude: [
                         /.+(Sync|Stream)$/
                     ],
                     errorFirst: true,
                     promiseModule: Promise
-                }, t);
+                }, r);
                 const filter = (e)=>{
-                    const match = (t)=>"string" == typeof t ? e === t : t.test(e);
-                    return t.include ? t.include.some(match) : !t.exclude.some(match);
+                    const match = (r)=>"string" == typeof r ? e === r : r.test(e);
+                    return r.include ? r.include.some(match) : !r.exclude.some(match);
                 };
-                let r;
-                r = "function" == typeof e ? function() {
-                    if (t.excludeMain) return e.apply(this, arguments);
-                    return processFn(e, t).apply(this, arguments);
+                let t;
+                t = "function" == typeof e ? function() {
+                    if (r.excludeMain) return e.apply(this, arguments);
+                    return processFn(e, r).apply(this, arguments);
                 } : Object.create(Object.getPrototypeOf(e));
                 for(const n in e){
                     const i = e[n];
-                    r[n] = "function" == typeof i && filter(n) ? processFn(i, t) : i;
+                    t[n] = "function" == typeof i && filter(n) ? processFn(i, r) : i;
                 }
-                return r;
+                return t;
             };
         },
-        817: (e, t, r)=>{
+        702: (e, r, t)=>{
             "use strict";
-            const n = r(17);
-            const i = r(834);
-            const s = r(324);
-            const o = new WeakMap;
-            const filepath = (e)=>o.get(e);
+            const n = t(928);
+            const i = t(378);
+            const a = t(903);
+            const s = new WeakMap;
+            const filepath = (e)=>s.get(e);
             const findNextCwd = (e)=>n.resolve(n.dirname(e), "..");
-            const addFp = (e, t)=>{
-                o.set(e, t);
+            const addFp = (e, r)=>{
+                s.set(e, r);
                 return e;
             };
-            const pkgConf = (e, t)=>{
+            const pkgConf = (e, r)=>{
                 if (!e) return Promise.reject(new TypeError("Expected a namespace"));
-                t = t || {};
-                return i("package.json", t.cwd ? {
-                    cwd: t.cwd
-                } : {}).then((r)=>{
-                    if (!r) return addFp(Object.assign({}, t.defaults), r);
-                    return s(r).then((n)=>{
-                        if (t.skipOnFalse && false === n[e]) {
-                            const n = Object.assign({}, t, {
-                                cwd: findNextCwd(r)
+                r = r || {};
+                return i("package.json", r.cwd ? {
+                    cwd: r.cwd
+                } : {}).then((t)=>{
+                    if (!t) return addFp(Object.assign({}, r.defaults), t);
+                    return a(t).then((n)=>{
+                        if (r.skipOnFalse && false === n[e]) {
+                            const n = Object.assign({}, r, {
+                                cwd: findNextCwd(t)
                             });
                             return pkgConf(e, n);
                         }
-                        return addFp(Object.assign({}, t.defaults, n[e]), r);
+                        return addFp(Object.assign({}, r.defaults, n[e]), t);
                     });
                 });
             };
-            const sync = (e, t)=>{
+            const sync = (e, r)=>{
                 if (!e) throw new TypeError("Expected a namespace");
-                t = t || {};
-                const r = i.sync("package.json", t.cwd ? {
-                    cwd: t.cwd
+                r = r || {};
+                const t = i.sync("package.json", r.cwd ? {
+                    cwd: r.cwd
                 } : {});
-                if (!r) return addFp(Object.assign({}, t.defaults), r);
-                const n = s.sync(r);
-                if (t.skipOnFalse && false === n[e]) {
-                    const n = Object.assign({}, t, {
-                        cwd: findNextCwd(r)
+                if (!t) return addFp(Object.assign({}, r.defaults), t);
+                const n = a.sync(t);
+                if (r.skipOnFalse && false === n[e]) {
+                    const n = Object.assign({}, r, {
+                        cwd: findNextCwd(t)
                     });
                     return sync(e, n);
                 }
-                return addFp(Object.assign({}, t.defaults, n[e]), r);
+                return addFp(Object.assign({}, r.defaults, n[e]), t);
             };
             e.exports = pkgConf;
             e.exports.filepath = filepath;
             e.exports.sync = sync;
         },
-        567: (e, t, r)=>{
+        208: (e, r, t)=>{
             "use strict";
-            const n = r(852);
+            const n = t(371);
             e.exports = Object.assign(new n, {
                 Signale: n
             });
         },
-        852: (e, t, r)=>{
+        371: (e, r, t)=>{
             "use strict";
-            const n = r(837);
-            const i = r(17);
-            const s = r(521);
-            const o = r(234);
-            const c = r(877);
-            const a = r(817);
-            const l = r(684);
-            const f = r(616);
-            const { green: u, grey: h, red: p, underline: d, yellow: g } = o;
-            let m = false;
-            const y = l.options.default;
+            const n = t(23);
+            const i = t(928);
+            const a = t(785);
+            const s = t(425);
+            const o = t(215);
+            const c = t(702);
+            const l = t(344);
+            const u = t(109);
+            const { green: f, grey: h, red: p, underline: g, yellow: d } = s;
+            let v = false;
+            const m = l.options.default;
             const b = l.name;
             class Signale {
                 constructor(e = {}){
@@ -1269,7 +3515,7 @@
                     this._disabled = e.disabled || false;
                     this._scopeName = e.scope || "";
                     this._timers = e.timers || new Map;
-                    this._types = this._mergeTypes(f, this._customTypes);
+                    this._types = this._mergeTypes(u, this._customTypes);
                     this._stream = e.stream || process.stdout;
                     this._longestLabel = this._getLongestLabel();
                     this._secrets = e.secrets || [];
@@ -1304,20 +3550,20 @@
                 }
                 get filename() {
                     const e = Error.prepareStackTrace;
-                    Error.prepareStackTrace = (e, t)=>t;
-                    const { stack: t } = new Error;
+                    Error.prepareStackTrace = (e, r)=>r;
+                    const { stack: r } = new Error;
                     Error.prepareStackTrace = e;
-                    const r = t.map((e)=>e.getFileName());
-                    const n = r.find((e)=>e !== r[0]);
+                    const t = r.map((e)=>e.getFileName());
+                    const n = t.find((e)=>e !== t[0]);
                     return n ? i.basename(n) : "anonymous";
                 }
                 get packageConfiguration() {
-                    return a.sync(b, {
-                        defaults: y
+                    return c.sync(b, {
+                        defaults: m
                     });
                 }
                 get _longestUnderlinedLabel() {
-                    return d(this._longestLabel);
+                    return g(this._longestLabel);
                 }
                 get _logLevels() {
                     return {
@@ -1341,27 +3587,27 @@
                 }
                 _getLongestLabel() {
                     const { _types: e } = this;
-                    const t = Object.keys(e).map((t)=>e[t].label);
-                    return t.reduce((e, t)=>e.length > t.length ? e : t);
+                    const r = Object.keys(e).map((r)=>e[r].label);
+                    return r.reduce((e, r)=>e.length > r.length ? e : r);
                 }
                 _validateLogLevel(e) {
                     return Object.keys(this._logLevels).includes(e) ? e : "info";
                 }
-                _mergeTypes(e, t) {
-                    const r = Object.assign({}, e);
-                    Object.keys(t).forEach((e)=>{
-                        r[e] = Object.assign({}, r[e], t[e]);
+                _mergeTypes(e, r) {
+                    const t = Object.assign({}, e);
+                    Object.keys(r).forEach((e)=>{
+                        t[e] = Object.assign({}, t[e], r[e]);
                     });
-                    return r;
+                    return t;
                 }
                 _filterSecrets(e) {
-                    const { _secrets: t } = this;
-                    if (0 === t.length) return e;
-                    let r = e;
-                    t.forEach((e)=>{
-                        r = r.replace(new RegExp(e, "g"), "[secure]");
+                    const { _secrets: r } = this;
+                    if (0 === r.length) return e;
+                    let t = e;
+                    r.forEach((e)=>{
+                        t = t.replace(new RegExp(e, "g"), "[secure]");
                     });
-                    return r;
+                    return t;
                 }
                 _formatStream(e) {
                     return this._arrayify(e);
@@ -1392,77 +3638,77 @@
                     if (this._config.displayFilename) e.push(this._formatFilename());
                     if (0 !== this._scopeName.length && this._config.displayScope) e.push(this._formatScopeName());
                     if (0 !== e.length) {
-                        e.push(`${c.pointerSmall}`);
+                        e.push(`${o.pointerSmall}`);
                         return e.map((e)=>h(e));
                     }
                     return e;
                 }
-                _hasAdditional({ suffix: e, prefix: t }, r) {
-                    return e || t ? "" : this._formatMessage(r);
+                _hasAdditional({ suffix: e, prefix: r }, t) {
+                    return e || r ? "" : this._formatMessage(t);
                 }
-                _buildSignale(e, ...t) {
-                    let [r, n] = [
+                _buildSignale(e, ...r) {
+                    let [t, n] = [
                         {},
                         {}
                     ];
-                    if (1 === t.length && "object" == typeof t[0] && null !== t[0]) if (t[0] instanceof Error) [r] = t;
+                    if (1 === r.length && "object" == typeof r[0] && null !== r[0]) if (r[0] instanceof Error) [t] = r;
                     else {
-                        const [{ prefix: e, message: i, suffix: s }] = t;
+                        const [{ prefix: e, message: i, suffix: a }] = r;
                         n = Object.assign({}, {
-                            suffix: s,
+                            suffix: a,
                             prefix: e
                         });
-                        r = i ? this._formatMessage(i) : this._hasAdditional(n, t);
+                        t = i ? this._formatMessage(i) : this._hasAdditional(n, r);
                     }
-                    else r = this._formatMessage(t);
+                    else t = this._formatMessage(r);
                     const i = this._meta();
-                    if (n.prefix) if (this._config.underlinePrefix) i.push(d(n.prefix));
+                    if (n.prefix) if (this._config.underlinePrefix) i.push(g(n.prefix));
                     else i.push(n.prefix);
-                    if (this._config.displayBadge && e.badge) i.push(o[e.color](this._padEnd(e.badge, e.badge.length + 1)));
+                    if (this._config.displayBadge && e.badge) i.push(s[e.color](this._padEnd(e.badge, e.badge.length + 1)));
                     if (this._config.displayLabel && e.label) {
-                        const t = this._config.uppercaseLabel ? e.label.toUpperCase() : e.label;
-                        if (this._config.underlineLabel) i.push(o[e.color](this._padEnd(d(t), this._longestUnderlinedLabel.length + 1)));
-                        else i.push(o[e.color](this._padEnd(t, this._longestLabel.length + 1)));
+                        const r = this._config.uppercaseLabel ? e.label.toUpperCase() : e.label;
+                        if (this._config.underlineLabel) i.push(s[e.color](this._padEnd(g(r), this._longestUnderlinedLabel.length + 1)));
+                        else i.push(s[e.color](this._padEnd(r, this._longestLabel.length + 1)));
                     }
-                    if (r instanceof Error && r.stack) {
-                        const [e, ...t] = r.stack.split("\n");
-                        if (this._config.underlineMessage) i.push(d(e));
+                    if (t instanceof Error && t.stack) {
+                        const [e, ...r] = t.stack.split("\n");
+                        if (this._config.underlineMessage) i.push(g(e));
                         else i.push(e);
-                        i.push(h(t.map((e)=>e.replace(/^/, "\n")).join("")));
+                        i.push(h(r.map((e)=>e.replace(/^/, "\n")).join("")));
                         return i.join(" ");
                     }
-                    if (this._config.underlineMessage) i.push(d(r));
-                    else i.push(r);
-                    if (n.suffix) if (this._config.underlineSuffix) i.push(d(n.suffix));
+                    if (this._config.underlineMessage) i.push(g(t));
+                    else i.push(t);
+                    if (n.suffix) if (this._config.underlineSuffix) i.push(g(n.suffix));
                     else i.push(n.suffix);
                     return i.join(" ");
                 }
-                _write(e, t) {
-                    if (this._interactive && e.isTTY && m) {
-                        s.moveCursor(e, 0, -1);
-                        s.clearLine(e);
-                        s.cursorTo(e, 0);
+                _write(e, r) {
+                    if (this._interactive && e.isTTY && v) {
+                        a.moveCursor(e, 0, -1);
+                        a.clearLine(e);
+                        a.cursorTo(e, 0);
                     }
-                    e.write(t + "\n");
-                    m = this._interactive;
+                    e.write(r + "\n");
+                    v = this._interactive;
                 }
-                _log(e, t = this._stream, r) {
-                    if (this.isEnabled() && this._logLevels[r] >= this._logLevels[this._generalLogLevel]) this._formatStream(t).forEach((t)=>{
-                        this._write(t, e);
+                _log(e, r = this._stream, t) {
+                    if (this.isEnabled() && this._logLevels[t] >= this._logLevels[this._generalLogLevel]) this._formatStream(r).forEach((r)=>{
+                        this._write(r, e);
                     });
                 }
-                _logger(e, ...t) {
-                    const { stream: r, logLevel: n } = this._types[e];
-                    const i = this._buildSignale(this._types[e], ...t);
-                    this._log(this._filterSecrets(i), r, this._validateLogLevel(n));
+                _logger(e, ...r) {
+                    const { stream: t, logLevel: n } = this._types[e];
+                    const i = this._buildSignale(this._types[e], ...r);
+                    this._log(this._filterSecrets(i), t, this._validateLogLevel(n));
                 }
-                _padEnd(e, t) {
+                _padEnd(e, r) {
                     e = String(e);
-                    t = parseInt(t, 10) || 0;
-                    if (e.length >= t) return e;
-                    if (String.prototype.padEnd) return e.padEnd(t);
-                    t -= e.length;
-                    return e + " ".repeat(t);
+                    r = parseInt(r, 10) || 0;
+                    if (e.length >= r) return e;
+                    if (String.prototype.padEnd) return e.padEnd(r);
+                    r -= e.length;
+                    return e + " ".repeat(r);
                 }
                 addSecrets(e) {
                     if (!Array.isArray(e)) throw new TypeError("Argument must be an array.");
@@ -1495,12 +3741,12 @@
                 time(e) {
                     if (!e) e = `timer_${this._timers.size}`;
                     this._timers.set(e, this._now);
-                    const t = this._meta();
-                    t.push(u(this._padEnd(this._types.start.badge, 2)));
-                    if (this._config.underlineLabel) t.push(u(this._padEnd(d(e), this._longestUnderlinedLabel.length + 1)));
-                    else t.push(u(this._padEnd(e, this._longestLabel.length + 1)));
-                    t.push("Initialized timer...");
-                    this._log(t.join(" "), this._stream, "timer");
+                    const r = this._meta();
+                    r.push(f(this._padEnd(this._types.start.badge, 2)));
+                    if (this._config.underlineLabel) r.push(f(this._padEnd(g(e), this._longestUnderlinedLabel.length + 1)));
+                    else r.push(f(this._padEnd(e, this._longestLabel.length + 1)));
+                    r.push("Initialized timer...");
+                    this._log(r.join(" "), this._stream, "timer");
                     return e;
                 }
                 timeEnd(e) {
@@ -1508,30 +3754,30 @@
                         const is = (e)=>e.includes("timer_");
                         e = [
                             ...this._timers.keys()
-                        ].reduceRight((e, t)=>is(e) ? e : is(t) ? t : null);
+                        ].reduceRight((e, r)=>is(e) ? e : is(r) ? r : null);
                     }
                     if (this._timers.has(e)) {
-                        const t = this._timeSpan(this._timers.get(e));
+                        const r = this._timeSpan(this._timers.get(e));
                         this._timers.delete(e);
-                        const r = this._meta();
-                        r.push(p(this._padEnd(this._types.pause.badge, 2)));
-                        if (this._config.underlineLabel) r.push(p(this._padEnd(d(e), this._longestUnderlinedLabel.length + 1)));
-                        else r.push(p(this._padEnd(e, this._longestLabel.length + 1)));
-                        r.push("Timer run for:");
-                        r.push(g(t < 1e3 ? t + "ms" : (t / 1e3).toFixed(2) + "s"));
-                        this._log(r.join(" "), this._stream, "timer");
+                        const t = this._meta();
+                        t.push(p(this._padEnd(this._types.pause.badge, 2)));
+                        if (this._config.underlineLabel) t.push(p(this._padEnd(g(e), this._longestUnderlinedLabel.length + 1)));
+                        else t.push(p(this._padEnd(e, this._longestLabel.length + 1)));
+                        t.push("Timer run for:");
+                        t.push(d(r < 1e3 ? r + "ms" : (r / 1e3).toFixed(2) + "s"));
+                        this._log(t.join(" "), this._stream, "timer");
                         return {
                             label: e,
-                            span: t
+                            span: r
                         };
                     }
                 }
             }
             e.exports = Signale;
         },
-        616: (e, t, r)=>{
+        109: (e, r, t)=>{
             "use strict";
-            const n = r(877);
+            const n = t(215);
             e.exports = {
                 error: {
                     badge: n.cross,
@@ -1637,7 +3883,7 @@
                 }
             };
         },
-        308: (e)=>{
+        878: (e)=>{
             "use strict";
             e.exports = (e)=>{
                 if ("string" != typeof e) throw new TypeError("Expected a string, got " + typeof e);
@@ -1645,60 +3891,135 @@
                 return e;
             };
         },
-        234: (e)=>{
+        791: (e, r, t)=>{
             "use strict";
-            e.exports = require("../chalk");
+            const n = t(857);
+            const i = t(254);
+            const a = process.env;
+            let s;
+            if (i("no-color") || i("no-colors") || i("color=false")) s = false;
+            else if (i("color") || i("colors") || i("color=true") || i("color=always")) s = true;
+            if ("FORCE_COLOR" in a) s = 0 === a.FORCE_COLOR.length || 0 !== parseInt(a.FORCE_COLOR, 10);
+            function translateLevel(e) {
+                if (0 === e) return false;
+                return {
+                    level: e,
+                    hasBasic: true,
+                    has256: e >= 2,
+                    has16m: e >= 3
+                };
+            }
+            function supportsColor(e) {
+                if (false === s) return 0;
+                if (i("color=16m") || i("color=full") || i("color=truecolor")) return 3;
+                if (i("color=256")) return 2;
+                if (e && !e.isTTY && true !== s) return 0;
+                const r = s ? 1 : 0;
+                if ("win32" === process.platform) {
+                    const e = n.release().split(".");
+                    if (Number(process.versions.node.split(".")[0]) >= 8 && Number(e[0]) >= 10 && Number(e[2]) >= 10586) return Number(e[2]) >= 14931 ? 3 : 2;
+                    return 1;
+                }
+                if ("CI" in a) {
+                    if ([
+                        "TRAVIS",
+                        "CIRCLECI",
+                        "APPVEYOR",
+                        "GITLAB_CI"
+                    ].some((e)=>e in a) || "codeship" === a.CI_NAME) return 1;
+                    return r;
+                }
+                if ("TEAMCITY_VERSION" in a) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(a.TEAMCITY_VERSION) ? 1 : 0;
+                if ("truecolor" === a.COLORTERM) return 3;
+                if ("TERM_PROGRAM" in a) {
+                    const e = parseInt((a.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+                    switch(a.TERM_PROGRAM){
+                        case "iTerm.app":
+                            return e >= 3 ? 3 : 2;
+                        case "Apple_Terminal":
+                            return 2;
+                    }
+                }
+                if (/-256(color)?$/i.test(a.TERM)) return 2;
+                if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(a.TERM)) return 1;
+                if ("COLORTERM" in a) return 1;
+                a.TERM;
+                return r;
+            }
+            function getSupportLevel(e) {
+                const r = supportsColor(e);
+                return translateLevel(r);
+            }
+            e.exports = {
+                supportsColor: getSupportLevel,
+                stdout: getSupportLevel(process.stdout),
+                stderr: getSupportLevel(process.stderr)
+            };
         },
-        684: (e)=>{
+        344: (e)=>{
             "use strict";
             e.exports = require("./package.json");
         },
-        491: (e)=>{
+        613: (e)=>{
             "use strict";
             e.exports = require("assert");
         },
-        57: (e)=>{
+        140: (e)=>{
             "use strict";
             e.exports = require("constants");
         },
-        147: (e)=>{
+        896: (e)=>{
             "use strict";
             e.exports = require("fs");
         },
-        17: (e)=>{
+        857: (e)=>{
+            "use strict";
+            e.exports = require("os");
+        },
+        928: (e)=>{
             "use strict";
             e.exports = require("path");
         },
-        521: (e)=>{
+        785: (e)=>{
             "use strict";
             e.exports = require("readline");
         },
-        781: (e)=>{
+        203: (e)=>{
             "use strict";
             e.exports = require("stream");
         },
-        837: (e)=>{
+        23: (e)=>{
             "use strict";
             e.exports = require("util");
         }
     };
-    var t = {};
-    function __nccwpck_require__(r) {
-        var n = t[r];
+    var r = {};
+    function __nccwpck_require__(t) {
+        var n = r[t];
         if (void 0 !== n) return n.exports;
-        var i = t[r] = {
+        var i = r[t] = {
+            id: t,
+            loaded: false,
             exports: {}
         };
-        var s = true;
+        var a = true;
         try {
-            e[r](i, i.exports, __nccwpck_require__);
-            s = false;
+            e[t](i, i.exports, __nccwpck_require__);
+            a = false;
         } finally{
-            if (s) delete t[r];
+            if (a) delete r[t];
         }
+        i.loaded = true;
         return i.exports;
     }
     if (void 0 !== __nccwpck_require__) __nccwpck_require__.ab = __dirname + "/";
-    var r = __nccwpck_require__(567);
-    module.exports = r;
+    (()=>{
+        __nccwpck_require__.nmd = (e)=>{
+            e.paths = [];
+            if (!e.children) e.children = [];
+            return e;
+        };
+    })();
+    var t = __nccwpck_require__(208);
+    module.exports = t;
 })();