@bleedingdev/modern-js-utils 3.2.0-ultramodern.0

package/dist/compiled/debug/index.d.ts

@@ -0,0 +1,54 @@
+// Type definitions for debug 4.1
+// Project: https://github.com/visionmedia/debug
+// Definitions by: Seon-Wook Park <https://github.com/swook>
+//                 Gal Talmor <https://github.com/galtalmor>
+//                 John McLaughlin <https://github.com/zamb3zi>
+//                 Brasten Sager <https://github.com/brasten>
+//                 Nicolas Penin <https://github.com/npenin>
+//                 Kristian Brünn <https://github.com/kristianmitk>
+//                 Caleb Gregory <https://github.com/calebgregory>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug };
+
+export = debug;
+export as namespace debug;
+
+declare namespace debug {
+    interface Debug {
+        (namespace: string): Debugger;
+        coerce: (val: any) => any;
+        disable: () => string;
+        enable: (namespaces: string) => void;
+        enabled: (namespaces: string) => boolean;
+        formatArgs: (this: Debugger, args: any[]) => void;
+        log: (...args: any[]) => any;
+        selectColor: (namespace: string) => string | number;
+        humanize: typeof import('./ms');
+
+        names: RegExp[];
+        skips: RegExp[];
+
+        formatters: Formatters;
+    }
+
+    type IDebug = Debug;
+
+    interface Formatters {
+        [formatter: string]: (v: any) => string;
+    }
+
+    type IDebugger = Debugger;
+
+    interface Debugger {
+        (formatter: any, ...args: any[]): void;
+
+        color: string;
+        diff: number;
+        enabled: boolean;
+        log: (...args: any[]) => any;
+        namespace: string;
+        destroy: () => boolean;
+        extend: (namespace: string, delimiter?: string) => Debugger;
+    }
+}

package/dist/compiled/debug/index.js

@@ -0,0 +1,621 @@
+(()=>{
+    var e = {
+        434: (e, t, r)=>{
+            t.formatArgs = formatArgs;
+            t.save = save;
+            t.load = load;
+            t.useColors = useColors;
+            t.storage = localstorage();
+            t.destroy = (()=>{
+                let e = false;
+                return ()=>{
+                    if (!e) {
+                        e = true;
+                        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+                    }
+                };
+            })();
+            t.colors = [
+                "#0000CC",
+                "#0000FF",
+                "#0033CC",
+                "#0033FF",
+                "#0066CC",
+                "#0066FF",
+                "#0099CC",
+                "#0099FF",
+                "#00CC00",
+                "#00CC33",
+                "#00CC66",
+                "#00CC99",
+                "#00CCCC",
+                "#00CCFF",
+                "#3300CC",
+                "#3300FF",
+                "#3333CC",
+                "#3333FF",
+                "#3366CC",
+                "#3366FF",
+                "#3399CC",
+                "#3399FF",
+                "#33CC00",
+                "#33CC33",
+                "#33CC66",
+                "#33CC99",
+                "#33CCCC",
+                "#33CCFF",
+                "#6600CC",
+                "#6600FF",
+                "#6633CC",
+                "#6633FF",
+                "#66CC00",
+                "#66CC33",
+                "#9900CC",
+                "#9900FF",
+                "#9933CC",
+                "#9933FF",
+                "#99CC00",
+                "#99CC33",
+                "#CC0000",
+                "#CC0033",
+                "#CC0066",
+                "#CC0099",
+                "#CC00CC",
+                "#CC00FF",
+                "#CC3300",
+                "#CC3333",
+                "#CC3366",
+                "#CC3399",
+                "#CC33CC",
+                "#CC33FF",
+                "#CC6600",
+                "#CC6633",
+                "#CC9900",
+                "#CC9933",
+                "#CCCC00",
+                "#CCCC33",
+                "#FF0000",
+                "#FF0033",
+                "#FF0066",
+                "#FF0099",
+                "#FF00CC",
+                "#FF00FF",
+                "#FF3300",
+                "#FF3333",
+                "#FF3366",
+                "#FF3399",
+                "#FF33CC",
+                "#FF33FF",
+                "#FF6600",
+                "#FF6633",
+                "#FF9900",
+                "#FF9933",
+                "#FFCC00",
+                "#FFCC33"
+            ];
+            function useColors() {
+                if ("u" > typeof window && window.process && ("renderer" === window.process.type || window.process.__nwjs)) return true;
+                if ("u" > typeof navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) return false;
+                return "u" > typeof document && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || "u" > typeof window && window.console && (window.console.firebug || window.console.exception && window.console.table) || "u" > typeof navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || "u" > typeof navigator && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+            }
+            function formatArgs(t) {
+                t[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + t[0] + (this.useColors ? "%c " : " ") + "+" + e.exports.humanize(this.diff);
+                if (!this.useColors) return;
+                const r = "color: " + this.color;
+                t.splice(1, 0, r, "color: inherit");
+                let s = 0;
+                let n = 0;
+                t[0].replace(/%[a-zA-Z%]/g, (e)=>{
+                    if ("%%" === e) return;
+                    s++;
+                    if ("%c" === e) n = s;
+                });
+                t.splice(n, 0, r);
+            }
+            t.log = console.debug || console.log || (()=>{});
+            function save(e) {
+                try {
+                    if (e) t.storage.setItem("debug", e);
+                    else t.storage.removeItem("debug");
+                } catch (e) {}
+            }
+            function load() {
+                let e;
+                try {
+                    e = t.storage.getItem("debug");
+                } catch (e) {}
+                if (!e && "u" > typeof process && "env" in process) e = process.env.DEBUG;
+                return e;
+            }
+            function localstorage() {
+                try {
+                    return localStorage;
+                } catch (e) {}
+            }
+            e.exports = r(290)(t);
+            const { formatters: s } = e.exports;
+            s.j = function(e) {
+                try {
+                    return JSON.stringify(e);
+                } catch (e) {
+                    return "[UnexpectedJSONParseError]: " + e.message;
+                }
+            };
+        },
+        290: (e, t, r)=>{
+            function setup(e) {
+                createDebug.debug = createDebug;
+                createDebug.default = createDebug;
+                createDebug.coerce = coerce;
+                createDebug.disable = disable;
+                createDebug.enable = enable;
+                createDebug.enabled = enabled;
+                createDebug.humanize = r(367);
+                createDebug.destroy = destroy;
+                Object.keys(e).forEach((t)=>{
+                    createDebug[t] = e[t];
+                });
+                createDebug.names = [];
+                createDebug.skips = [];
+                createDebug.formatters = {};
+                function selectColor(e) {
+                    let t = 0;
+                    for(let r = 0; r < e.length; r++){
+                        t = (t << 5) - t + e.charCodeAt(r);
+                        t |= 0;
+                    }
+                    return createDebug.colors[Math.abs(t) % createDebug.colors.length];
+                }
+                createDebug.selectColor = selectColor;
+                function createDebug(e) {
+                    let t;
+                    let r = null;
+                    let s;
+                    let n;
+                    function debug(...e) {
+                        if (!debug.enabled) return;
+                        const r = debug;
+                        const s = Number(new Date);
+                        const n = s - (t || s);
+                        r.diff = n;
+                        r.prev = t;
+                        r.curr = s;
+                        t = s;
+                        e[0] = createDebug.coerce(e[0]);
+                        if ("string" != typeof e[0]) e.unshift("%O");
+                        let o = 0;
+                        e[0] = e[0].replace(/%([a-zA-Z%])/g, (t, s)=>{
+                            if ("%%" === t) return "%";
+                            o++;
+                            const n = createDebug.formatters[s];
+                            if ("function" == typeof n) {
+                                const s = e[o];
+                                t = n.call(r, s);
+                                e.splice(o, 1);
+                                o--;
+                            }
+                            return t;
+                        });
+                        createDebug.formatArgs.call(r, e);
+                        const a = r.log || createDebug.log;
+                        a.apply(r, e);
+                    }
+                    debug.namespace = e;
+                    debug.useColors = createDebug.useColors();
+                    debug.color = createDebug.selectColor(e);
+                    debug.extend = extend;
+                    debug.destroy = createDebug.destroy;
+                    Object.defineProperty(debug, "enabled", {
+                        enumerable: true,
+                        configurable: false,
+                        get: ()=>{
+                            if (null !== r) return r;
+                            if (s !== createDebug.namespaces) {
+                                s = createDebug.namespaces;
+                                n = createDebug.enabled(e);
+                            }
+                            return n;
+                        },
+                        set: (e)=>{
+                            r = e;
+                        }
+                    });
+                    if ("function" == typeof createDebug.init) createDebug.init(debug);
+                    return debug;
+                }
+                function extend(e, t) {
+                    const r = createDebug(this.namespace + (void 0 === t ? ":" : t) + e);
+                    r.log = this.log;
+                    return r;
+                }
+                function enable(e) {
+                    createDebug.save(e);
+                    createDebug.namespaces = e;
+                    createDebug.names = [];
+                    createDebug.skips = [];
+                    let t;
+                    const r = ("string" == typeof e ? e : "").split(/[\s,]+/);
+                    const s = r.length;
+                    for(t = 0; t < s; t++)if (r[t]) {
+                        e = r[t].replace(/\*/g, ".*?");
+                        if ("-" === e[0]) createDebug.skips.push(new RegExp("^" + e.slice(1) + "$"));
+                        else createDebug.names.push(new RegExp("^" + e + "$"));
+                    }
+                }
+                function disable() {
+                    const e = [
+                        ...createDebug.names.map(toNamespace),
+                        ...createDebug.skips.map(toNamespace).map((e)=>"-" + e)
+                    ].join(",");
+                    createDebug.enable("");
+                    return e;
+                }
+                function enabled(e) {
+                    if ("*" === e[e.length - 1]) return true;
+                    let t;
+                    let r;
+                    for(t = 0, r = createDebug.skips.length; t < r; t++)if (createDebug.skips[t].test(e)) return false;
+                    for(t = 0, r = createDebug.names.length; t < r; t++)if (createDebug.names[t].test(e)) return true;
+                    return false;
+                }
+                function toNamespace(e) {
+                    return e.toString().substring(2, e.toString().length - 2).replace(/\.\*\?$/, "*");
+                }
+                function coerce(e) {
+                    if (e instanceof Error) return e.stack || e.message;
+                    return e;
+                }
+                function destroy() {
+                    console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+                }
+                createDebug.enable(createDebug.load());
+                return createDebug;
+            }
+            e.exports = setup;
+        },
+        372: (e, t, r)=>{
+            if ("u" < typeof process || "renderer" === process.type || true === process.browser || process.__nwjs) e.exports = r(434);
+            else e.exports = r(970);
+        },
+        970: (e, t, r)=>{
+            const s = r(224);
+            const n = r(837);
+            t.init = init;
+            t.log = log;
+            t.formatArgs = formatArgs;
+            t.save = save;
+            t.load = load;
+            t.useColors = useColors;
+            t.destroy = n.deprecate(()=>{}, "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+            t.colors = [
+                6,
+                2,
+                3,
+                4,
+                5,
+                1
+            ];
+            try {
+                const e = r(332);
+                if (e && (e.stderr || e).level >= 2) t.colors = [
+                    20,
+                    21,
+                    26,
+                    27,
+                    32,
+                    33,
+                    38,
+                    39,
+                    40,
+                    41,
+                    42,
+                    43,
+                    44,
+                    45,
+                    56,
+                    57,
+                    62,
+                    63,
+                    68,
+                    69,
+                    74,
+                    75,
+                    76,
+                    77,
+                    78,
+                    79,
+                    80,
+                    81,
+                    92,
+                    93,
+                    98,
+                    99,
+                    112,
+                    113,
+                    128,
+                    129,
+                    134,
+                    135,
+                    148,
+                    149,
+                    160,
+                    161,
+                    162,
+                    163,
+                    164,
+                    165,
+                    166,
+                    167,
+                    168,
+                    169,
+                    170,
+                    171,
+                    172,
+                    173,
+                    178,
+                    179,
+                    184,
+                    185,
+                    196,
+                    197,
+                    198,
+                    199,
+                    200,
+                    201,
+                    202,
+                    203,
+                    204,
+                    205,
+                    206,
+                    207,
+                    208,
+                    209,
+                    214,
+                    215,
+                    220,
+                    221
+                ];
+            } catch (e) {}
+            t.inspectOpts = Object.keys(process.env).filter((e)=>/^debug_/i.test(e)).reduce((e, t)=>{
+                const r = t.substring(6).toLowerCase().replace(/_([a-z])/g, (e, t)=>t.toUpperCase());
+                let s = process.env[t];
+                s = /^(yes|on|true|enabled)$/i.test(s) ? true : /^(no|off|false|disabled)$/i.test(s) ? false : "null" === s ? null : Number(s);
+                e[r] = s;
+                return e;
+            }, {});
+            function useColors() {
+                return "colors" in t.inspectOpts ? Boolean(t.inspectOpts.colors) : s.isatty(process.stderr.fd);
+            }
+            function formatArgs(t) {
+                const { namespace: r, useColors: s } = this;
+                if (s) {
+                    const s = this.color;
+                    const n = "[3" + (s < 8 ? s : "8;5;" + s);
+                    const o = `  ${n};1m${r} `;
+                    t[0] = o + t[0].split("\n").join("\n" + o);
+                    t.push(n + "m+" + e.exports.humanize(this.diff) + "");
+                } else t[0] = getDate() + r + " " + t[0];
+            }
+            function getDate() {
+                if (t.inspectOpts.hideDate) return "";
+                return (new Date).toISOString() + " ";
+            }
+            function log(...e) {
+                return process.stderr.write(n.format(...e) + "\n");
+            }
+            function save(e) {
+                if (e) process.env.DEBUG = e;
+                else delete process.env.DEBUG;
+            }
+            function load() {
+                return process.env.DEBUG;
+            }
+            function init(e) {
+                e.inspectOpts = {};
+                const r = Object.keys(t.inspectOpts);
+                for(let s = 0; s < r.length; s++)e.inspectOpts[r[s]] = t.inspectOpts[r[s]];
+            }
+            e.exports = r(290)(t);
+            const { formatters: o } = e.exports;
+            o.o = function(e) {
+                this.inspectOpts.colors = this.useColors;
+                return n.inspect(e, this.inspectOpts).split("\n").map((e)=>e.trim()).join(" ");
+            };
+            o.O = function(e) {
+                this.inspectOpts.colors = this.useColors;
+                return n.inspect(e, this.inspectOpts);
+            };
+        },
+        419: (e)=>{
+            "use strict";
+            e.exports = (e, t)=>{
+                t = t || process.argv;
+                const r = e.startsWith("-") ? "" : 1 === e.length ? "-" : "--";
+                const s = t.indexOf(r + e);
+                const n = t.indexOf("--");
+                return -1 !== s && (-1 === n ? true : s < n);
+            };
+        },
+        367: (e)=>{
+            var t = 1e3;
+            var r = 60 * t;
+            var s = 60 * r;
+            var n = 24 * s;
+            var o = 7 * n;
+            var a = 365.25 * n;
+            e.exports = function(e, t) {
+                t = t || {};
+                var r = typeof e;
+                if ("string" === r && e.length > 0) return parse(e);
+                if ("number" === r && isFinite(e)) return t.long ? fmtLong(e) : fmtShort(e);
+                throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(e));
+            };
+            function parse(e) {
+                e = String(e);
+                if (e.length > 100) return;
+                var c = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(e);
+                if (!c) return;
+                var u = parseFloat(c[1]);
+                var i = (c[2] || "ms").toLowerCase();
+                switch(i){
+                    case "years":
+                    case "year":
+                    case "yrs":
+                    case "yr":
+                    case "y":
+                        return u * a;
+                    case "weeks":
+                    case "week":
+                    case "w":
+                        return u * o;
+                    case "days":
+                    case "day":
+                    case "d":
+                        return u * n;
+                    case "hours":
+                    case "hour":
+                    case "hrs":
+                    case "hr":
+                    case "h":
+                        return u * s;
+                    case "minutes":
+                    case "minute":
+                    case "mins":
+                    case "min":
+                    case "m":
+                        return u * r;
+                    case "seconds":
+                    case "second":
+                    case "secs":
+                    case "sec":
+                    case "s":
+                        return u * t;
+                    case "milliseconds":
+                    case "millisecond":
+                    case "msecs":
+                    case "msec":
+                    case "ms":
+                        return u;
+                    default:
+                        return;
+                }
+            }
+            function fmtShort(e) {
+                var o = Math.abs(e);
+                if (o >= n) return Math.round(e / n) + "d";
+                if (o >= s) return Math.round(e / s) + "h";
+                if (o >= r) return Math.round(e / r) + "m";
+                if (o >= t) return Math.round(e / t) + "s";
+                return e + "ms";
+            }
+            function fmtLong(e) {
+                var o = Math.abs(e);
+                if (o >= n) return plural(e, o, n, "day");
+                if (o >= s) return plural(e, o, s, "hour");
+                if (o >= r) return plural(e, o, r, "minute");
+                if (o >= t) return plural(e, o, t, "second");
+                return e + " ms";
+            }
+            function plural(e, t, r, s) {
+                var n = t >= 1.5 * r;
+                return Math.round(e / r) + " " + s + (n ? "s" : "");
+            }
+        },
+        332: (e, t, r)=>{
+            "use strict";
+            const s = r(37);
+            const n = r(419);
+            const o = process.env;
+            let a;
+            if (n("no-color") || n("no-colors") || n("color=false")) a = false;
+            else if (n("color") || n("colors") || n("color=true") || n("color=always")) a = true;
+            if ("FORCE_COLOR" in o) a = 0 === o.FORCE_COLOR.length || 0 !== parseInt(o.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 === a) return 0;
+                if (n("color=16m") || n("color=full") || n("color=truecolor")) return 3;
+                if (n("color=256")) return 2;
+                if (e && !e.isTTY && true !== a) return 0;
+                const t = a ? 1 : 0;
+                if ("win32" === process.platform) {
+                    const e = s.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 o) {
+                    if ([
+                        "TRAVIS",
+                        "CIRCLECI",
+                        "APPVEYOR",
+                        "GITLAB_CI"
+                    ].some((e)=>e in o) || "codeship" === o.CI_NAME) return 1;
+                    return t;
+                }
+                if ("TEAMCITY_VERSION" in o) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(o.TEAMCITY_VERSION) ? 1 : 0;
+                if ("truecolor" === o.COLORTERM) return 3;
+                if ("TERM_PROGRAM" in o) {
+                    const e = parseInt((o.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+                    switch(o.TERM_PROGRAM){
+                        case "iTerm.app":
+                            return e >= 3 ? 3 : 2;
+                        case "Apple_Terminal":
+                            return 2;
+                    }
+                }
+                if (/-256(color)?$/i.test(o.TERM)) return 2;
+                if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(o.TERM)) return 1;
+                if ("COLORTERM" in o) return 1;
+                o.TERM;
+                return t;
+            }
+            function getSupportLevel(e) {
+                const t = supportsColor(e);
+                return translateLevel(t);
+            }
+            e.exports = {
+                supportsColor: getSupportLevel,
+                stdout: getSupportLevel(process.stdout),
+                stderr: getSupportLevel(process.stderr)
+            };
+        },
+        37: (e)=>{
+            "use strict";
+            e.exports = require("os");
+        },
+        224: (e)=>{
+            "use strict";
+            e.exports = require("tty");
+        },
+        837: (e)=>{
+            "use strict";
+            e.exports = require("util");
+        }
+    };
+    var t = {};
+    function __nccwpck_require__(r) {
+        var s = t[r];
+        if (void 0 !== s) return s.exports;
+        var n = t[r] = {
+            exports: {}
+        };
+        var o = true;
+        try {
+            e[r](n, n.exports, __nccwpck_require__);
+            o = false;
+        } finally{
+            if (o) delete t[r];
+        }
+        return n.exports;
+    }
+    if (void 0 !== __nccwpck_require__) __nccwpck_require__.ab = __dirname + "/";
+    var r = __nccwpck_require__(372);
+    module.exports = r;
+})();

package/dist/compiled/debug/license

@@ -0,0 +1,20 @@
+(The MIT License)
+
+Copyright (c) 2014-2017 TJ Holowaychuk <tj@vision-media.ca>
+Copyright (c) 2018-2021 Josh Junon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the 'Software'), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+