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

package/dist/compiled/mime-types/index.js.LICENSE.txt

@@ -0,0 +1,13 @@
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015-2022 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */

package/dist/compiled/mime-types/license

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+
+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.

package/dist/compiled/mime-types/package.json

@@ -0,0 +1 @@
+{"name":"mime-types","version":"2.1.35","license":"MIT"}

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

@@ -0,0 +1,95 @@
+// Type definitions for minimist 1.2
+// Project: https://github.com/substack/minimist
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+//                 Necroskillz <https://github.com/Necroskillz>
+//                 kamranayub <https://github.com/kamranayub>
+//                 Piotr Błażejewicz <https://github.com/peterblazejewicz>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/**
+ * Return an argument object populated with the array arguments from args
+ *
+ * @param [args] An optional argument array (typically `process.argv.slice(2)`)
+ * @param [opts] An optional options object to customize the parsing
+ */
+declare function minimist(args?: string[], opts?: minimist.Opts): minimist.ParsedArgs;
+
+/**
+ * Return an argument object populated with the array arguments from args. Strongly-typed
+ * to be the intersect of type T with minimist.ParsedArgs.
+ *
+ * `T` The type that will be intersected with minimist.ParsedArgs to represent the argument object
+ *
+ * @param [args] An optional argument array (typically `process.argv.slice(2)`)
+ * @param [opts] An optional options object to customize the parsing
+ */
+declare function minimist<T>(args?: string[], opts?: minimist.Opts): T & minimist.ParsedArgs;
+
+/**
+ * Return an argument object populated with the array arguments from args. Strongly-typed
+ * to be the the type T which should extend minimist.ParsedArgs
+ *
+ * `T` The type that extends minimist.ParsedArgs and represents the argument object
+ *
+ * @param [args] An optional argument array (typically `process.argv.slice(2)`)
+ * @param [opts] An optional options object to customize the parsing
+ */
+declare function minimist<T extends minimist.ParsedArgs>(args?: string[], opts?: minimist.Opts): T;
+
+declare namespace minimist {
+    interface Opts {
+        /**
+         * A string or array of strings argument names to always treat as strings
+         */
+        string?: string | string[] | undefined;
+
+        /**
+         * A boolean, string or array of strings to always treat as booleans. If true will treat
+         * all double hyphenated arguments without equals signs as boolean (e.g. affects `--foo`, not `-f` or `--foo=bar`)
+         */
+        boolean?: boolean | string | string[] | undefined;
+
+        /**
+         * An object mapping string names to strings or arrays of string argument names to use as aliases
+         */
+        alias?: { [key: string]: string | string[] } | undefined;
+
+        /**
+         * An object mapping string argument names to default values
+         */
+        default?: { [key: string]: any } | undefined;
+
+        /**
+         * When true, populate argv._ with everything after the first non-option
+         */
+        stopEarly?: boolean | undefined;
+
+        /**
+         * A function which is invoked with a command line parameter not defined in the opts
+         * configuration object. If the function returns false, the unknown option is not added to argv
+         */
+        unknown?: ((arg: string) => boolean) | undefined;
+
+        /**
+         * When true, populate argv._ with everything before the -- and argv['--'] with everything after the --.
+         * Note that with -- set, parsing for arguments still stops after the `--`.
+         */
+        '--'?: boolean | undefined;
+    }
+
+    interface ParsedArgs {
+        [arg: string]: any;
+
+        /**
+         * If opts['--'] is true, populated with everything after the --
+         */
+        '--'?: string[] | undefined;
+
+        /**
+         * Contains all the arguments that didn't have an option associated with them
+         */
+        _: string[];
+    }
+}
+
+export = minimist;

package/dist/compiled/minimist/index.js

@@ -0,0 +1,202 @@
+(()=>{
+    var e = {
+        319: (e)=>{
+            e.exports = function(e, t) {
+                if (!t) t = {};
+                var r = {
+                    bools: {},
+                    strings: {},
+                    unknownFn: null
+                };
+                if ("function" == typeof t["unknown"]) r.unknownFn = t["unknown"];
+                if ("boolean" == typeof t["boolean"] && t["boolean"]) r.allBools = true;
+                else [].concat(t["boolean"]).filter(Boolean).forEach(function(e) {
+                    r.bools[e] = true;
+                });
+                var n = {};
+                Object.keys(t.alias || {}).forEach(function(e) {
+                    n[e] = [].concat(t.alias[e]);
+                    n[e].forEach(function(t) {
+                        n[t] = [
+                            e
+                        ].concat(n[e].filter(function(e) {
+                            return t !== e;
+                        }));
+                    });
+                });
+                [].concat(t.string).filter(Boolean).forEach(function(e) {
+                    r.strings[e] = true;
+                    if (n[e]) r.strings[n[e]] = true;
+                });
+                var o = t["default"] || {};
+                var s = {
+                    _: []
+                };
+                Object.keys(r.bools).forEach(function(e) {
+                    setArg(e, void 0 === o[e] ? false : o[e]);
+                });
+                var i = [];
+                if (-1 !== e.indexOf("--")) {
+                    i = e.slice(e.indexOf("--") + 1);
+                    e = e.slice(0, e.indexOf("--"));
+                }
+                function argDefined(e, t) {
+                    return r.allBools && /^--[^=]+$/.test(t) || r.strings[e] || r.bools[e] || n[e];
+                }
+                function setArg(e, t, o) {
+                    if (o && r.unknownFn && !argDefined(e, o)) {
+                        if (false === r.unknownFn(o)) return;
+                    }
+                    var i = !r.strings[e] && isNumber(t) ? Number(t) : t;
+                    setKey(s, e.split("."), i);
+                    (n[e] || []).forEach(function(e) {
+                        setKey(s, e.split("."), i);
+                    });
+                }
+                function setKey(e, t, n) {
+                    var o = e;
+                    for(var s = 0; s < t.length - 1; s++){
+                        var i = t[s];
+                        if (isConstructorOrProto(o, i)) return;
+                        if (void 0 === o[i]) o[i] = {};
+                        if (o[i] === Object.prototype || o[i] === Number.prototype || o[i] === String.prototype) o[i] = {};
+                        if (o[i] === Array.prototype) o[i] = [];
+                        o = o[i];
+                    }
+                    var i = t[t.length - 1];
+                    if (isConstructorOrProto(o, i)) return;
+                    if (o === Object.prototype || o === Number.prototype || o === String.prototype) o = {};
+                    if (o === Array.prototype) o = [];
+                    if (void 0 === o[i] || r.bools[i] || "boolean" == typeof o[i]) o[i] = n;
+                    else if (Array.isArray(o[i])) o[i].push(n);
+                    else o[i] = [
+                        o[i],
+                        n
+                    ];
+                }
+                function aliasIsBoolean(e) {
+                    return n[e].some(function(e) {
+                        return r.bools[e];
+                    });
+                }
+                for(var a = 0; a < e.length; a++){
+                    var f = e[a];
+                    if (/^--.+=/.test(f)) {
+                        var u = f.match(/^--([^=]+)=([\s\S]*)$/);
+                        var l = u[1];
+                        var c = u[2];
+                        if (r.bools[l]) c = "false" !== c;
+                        setArg(l, c, f);
+                    } else if (/^--no-.+/.test(f)) {
+                        var l = f.match(/^--no-(.+)/)[1];
+                        setArg(l, false, f);
+                    } else if (/^--.+/.test(f)) {
+                        var l = f.match(/^--(.+)/)[1];
+                        var p = e[a + 1];
+                        if (void 0 === p || /^-/.test(p) || r.bools[l] || r.allBools || (n[l] ? aliasIsBoolean(l) : false)) if (/^(true|false)$/.test(p)) {
+                            setArg(l, "true" === p, f);
+                            a++;
+                        } else setArg(l, r.strings[l] ? "" : true, f);
+                        else {
+                            setArg(l, p, f);
+                            a++;
+                        }
+                    } else if (/^-[^-]+/.test(f)) {
+                        var b = f.slice(1, -1).split("");
+                        var _ = false;
+                        for(var g = 0; g < b.length; g++){
+                            var p = f.slice(g + 2);
+                            if ("-" === p) {
+                                setArg(b[g], p, f);
+                                continue;
+                            }
+                            if (/[A-Za-z]/.test(b[g]) && /=/.test(p)) {
+                                setArg(b[g], p.split("=")[1], f);
+                                _ = true;
+                                break;
+                            }
+                            if (/[A-Za-z]/.test(b[g]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(p)) {
+                                setArg(b[g], p, f);
+                                _ = true;
+                                break;
+                            }
+                            if (b[g + 1] && b[g + 1].match(/\W/)) {
+                                setArg(b[g], f.slice(g + 2), f);
+                                _ = true;
+                                break;
+                            }
+                            setArg(b[g], r.strings[b[g]] ? "" : true, f);
+                        }
+                        var l = f.slice(-1)[0];
+                        if (!_ && "-" !== l) if (!e[a + 1] || /^(-|--)[^-]/.test(e[a + 1]) || r.bools[l] || (n[l] ? aliasIsBoolean(l) : false)) if (e[a + 1] && /^(true|false)$/.test(e[a + 1])) {
+                            setArg(l, "true" === e[a + 1], f);
+                            a++;
+                        } else setArg(l, r.strings[l] ? "" : true, f);
+                        else {
+                            setArg(l, e[a + 1], f);
+                            a++;
+                        }
+                    } else {
+                        if (!r.unknownFn || false !== r.unknownFn(f)) s._.push(r.strings["_"] || !isNumber(f) ? f : Number(f));
+                        if (t.stopEarly) {
+                            s._.push.apply(s._, e.slice(a + 1));
+                            break;
+                        }
+                    }
+                }
+                Object.keys(o).forEach(function(e) {
+                    if (!hasKey(s, e.split("."))) {
+                        setKey(s, e.split("."), o[e]);
+                        (n[e] || []).forEach(function(t) {
+                            setKey(s, t.split("."), o[e]);
+                        });
+                    }
+                });
+                if (t["--"]) {
+                    s["--"] = new Array;
+                    i.forEach(function(e) {
+                        s["--"].push(e);
+                    });
+                } else i.forEach(function(e) {
+                    s._.push(e);
+                });
+                return s;
+            };
+            function hasKey(e, t) {
+                var r = e;
+                t.slice(0, -1).forEach(function(e) {
+                    r = r[e] || {};
+                });
+                var n = t[t.length - 1];
+                return n in r;
+            }
+            function isNumber(e) {
+                if ("number" == typeof e) return true;
+                if (/^0x[0-9a-f]+$/i.test(e)) return true;
+                return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(e);
+            }
+            function isConstructorOrProto(e, t) {
+                return "constructor" === t && "function" == typeof e[t] || "__proto__" === t;
+            }
+        }
+    };
+    var t = {};
+    function __nccwpck_require__(r) {
+        var n = t[r];
+        if (void 0 !== n) return n.exports;
+        var o = t[r] = {
+            exports: {}
+        };
+        var s = true;
+        try {
+            e[r](o, o.exports, __nccwpck_require__);
+            s = false;
+        } finally{
+            if (s) delete t[r];
+        }
+        return o.exports;
+    }
+    if (void 0 !== __nccwpck_require__) __nccwpck_require__.ab = __dirname + "/";
+    var r = __nccwpck_require__(319);
+    module.exports = r;
+})();

package/dist/compiled/minimist/license

@@ -0,0 +1,18 @@
+This software is released under the MIT license:
+
+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.

package/dist/compiled/minimist/package.json

@@ -0,0 +1 @@
+{"name":"minimist","author":{"name":"James Halliday","email":"mail@substack.net","url":"http://substack.net"},"version":"1.2.6","license":"MIT"}

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

@@ -0,0 +1,91 @@
+/**
+ * Generate secure URL-friendly unique ID.
+ *
+ * By default, the ID will have 21 symbols to have a collision probability
+ * similar to UUID v4.
+ *
+ * ```js
+ * import { nanoid } from './nanoid'
+ * model.id = nanoid() //=> "Uakgb_J5m9g-0JDMbcJqL"
+ * ```
+ *
+ * @param size Size of the ID. The default size is 21.
+ * @returns A random string.
+ */
+export function nanoid(size?: number): string
+
+/**
+ * Generate secure unique ID with custom alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * @param alphabet Alphabet used to generate the ID.
+ * @param defaultSize Size of the ID. The default size is 21.
+ * @returns A random string generator.
+ *
+ * ```js
+ * const { customAlphabet } = require('nanoid')
+ * const nanoid = customAlphabet('0123456789абвгдеё', 5)
+ * nanoid() //=> "8ё56а"
+ * ```
+ */
+export function customAlphabet(
+  alphabet: string,
+  defaultSize?: number
+): (size?: number) => string
+
+/**
+ * Generate unique ID with custom random generator and alphabet.
+ *
+ * Alphabet must contain 256 symbols or less. Otherwise, the generator
+ * will not be secure.
+ *
+ * ```js
+ * import { customRandom } from './nanoid/format'
+ *
+ * const nanoid = customRandom('abcdef', 5, size => {
+ *   const random = []
+ *   for (let i = 0; i < size; i++) {
+ *     random.push(randomByte())
+ *   }
+ *   return random
+ * })
+ *
+ * nanoid() //=> "fbaef"
+ * ```
+ *
+ * @param alphabet Alphabet used to generate a random string.
+ * @param size Size of the random string.
+ * @param random A random bytes generator.
+ * @returns A random string generator.
+ */
+export function customRandom(
+  alphabet: string,
+  size: number,
+  random: (bytes: number) => Uint8Array
+): () => string
+
+/**
+ * URL safe symbols.
+ *
+ * ```js
+ * import { urlAlphabet } from './nanoid'
+ * const nanoid = customAlphabet(urlAlphabet, 10)
+ * nanoid() //=> "Uakgb_J5m9"
+ * ```
+ */
+export const urlAlphabet: string
+
+/**
+ * Generate an array of random bytes collected from hardware noise.
+ *
+ * ```js
+ * import { customRandom, random } from './nanoid'
+ * const nanoid = customRandom("abcdef", 5, random)
+ * ```
+ *
+ * @param bytes Size of the array.
+ * @returns An array of random bytes.
+ */
+export function random(bytes: number): Uint8Array

package/dist/compiled/nanoid/index.js

@@ -0,0 +1,83 @@
+(()=>{
+    var e = {
+        982: (e)=>{
+            "use strict";
+            e.exports = require("crypto");
+        },
+        812: (e, r, t)=>{
+            let l = t(982);
+            let { urlAlphabet: a } = t(132);
+            const n = 128;
+            let _, u;
+            let fillPool = (e)=>{
+                if (!_ || _.length < e) {
+                    _ = Buffer.allocUnsafe(e * n);
+                    l.randomFillSync(_);
+                    u = 0;
+                } else if (u + e > _.length) {
+                    l.randomFillSync(_);
+                    u = 0;
+                }
+                u += e;
+            };
+            let random = (e)=>{
+                fillPool(e |= 0);
+                return _.subarray(u - e, u);
+            };
+            let customRandom = (e, r, t)=>{
+                let l = (2 << 31 - Math.clz32(e.length - 1 | 1)) - 1;
+                let a = Math.ceil(1.6 * l * r / e.length);
+                return (n = r)=>{
+                    let _ = "";
+                    while(true){
+                        let r = t(a);
+                        let u = a;
+                        while(u--){
+                            _ += e[r[u] & l] || "";
+                            if (_.length === n) return _;
+                        }
+                    }
+                };
+            };
+            let customAlphabet = (e, r = 21)=>customRandom(e, r, random);
+            let nanoid = (e = 21)=>{
+                fillPool(e |= 0);
+                let r = "";
+                for(let t = u - e; t < u; t++)r += a[63 & _[t]];
+                return r;
+            };
+            e.exports = {
+                nanoid: nanoid,
+                customAlphabet: customAlphabet,
+                customRandom: customRandom,
+                urlAlphabet: a,
+                random: random
+            };
+        },
+        132: (e)=>{
+            let r = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+            e.exports = {
+                urlAlphabet: r
+            };
+        }
+    };
+    var r = {};
+    function __nccwpck_require__(t) {
+        var l = r[t];
+        if (void 0 !== l) return l.exports;
+        var a = r[t] = {
+            exports: {}
+        };
+        var n = true;
+        try {
+            e[t](a, a.exports, __nccwpck_require__);
+            n = false;
+        } finally{
+            if (n) delete r[t];
+        }
+        return a.exports;
+    }
+    if (void 0 !== __nccwpck_require__) __nccwpck_require__.ab = __dirname + "/";
+    var t = __nccwpck_require__(812);
+    module.exports = t;
+})();

package/dist/compiled/nanoid/index.mjs

@@ -0,0 +1,69 @@
+import { createRequire as e } from "module";
+var t = {};
+(()=>{
+    t.d = (e, r)=>{
+        for(var l in r)if (t.o(r, l) && !t.o(e, l)) Object.defineProperty(e, l, {
+            enumerable: true,
+            get: r[l]
+        });
+    };
+})();
+(()=>{
+    t.o = (e, t)=>Object.prototype.hasOwnProperty.call(e, t);
+})();
+if (void 0 !== t) t.ab = new URL(".", import.meta.url).pathname.slice(import.meta.url.match(/^file:\/\/\/\w:/) ? 1 : 0, -1) + "/";
+var r = {};
+t.d(r, {
+    d_: ()=>customAlphabet,
+    NM: ()=>customRandom,
+    Ak: ()=>nanoid,
+    yT: ()=>random,
+    xO: ()=>a
+});
+const l = e(import.meta.url)("crypto");
+let a = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+const n = 128;
+let o, i;
+let fillPool = (e)=>{
+    if (!o || o.length < e) {
+        o = Buffer.allocUnsafe(e * n);
+        l.randomFillSync(o);
+        i = 0;
+    } else if (i + e > o.length) {
+        l.randomFillSync(o);
+        i = 0;
+    }
+    i += e;
+};
+let random = (e)=>{
+    fillPool(e |= 0);
+    return o.subarray(i - e, i);
+};
+let customRandom = (e, t, r)=>{
+    let l = (2 << 31 - Math.clz32(e.length - 1 | 1)) - 1;
+    let a = Math.ceil(1.6 * l * t / e.length);
+    return (n = t)=>{
+        let o = "";
+        while(true){
+            let t = r(a);
+            let i = a;
+            while(i--){
+                o += e[t[i] & l] || "";
+                if (o.length === n) return o;
+            }
+        }
+    };
+};
+let customAlphabet = (e, t = 21)=>customRandom(e, t, random);
+let nanoid = (e = 21)=>{
+    fillPool(e |= 0);
+    let t = "";
+    for(let r = i - e; r < i; r++)t += a[63 & o[r]];
+    return t;
+};
+var m = r.d_;
+var u = r.NM;
+var c = r.Ak;
+var f = r.yT;
+var s = r.xO;
+export { m as customAlphabet, u as customRandom, c as nanoid, f as random, s as urlAlphabet };

package/dist/compiled/nanoid/license

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright 2017 Andrey Sitnik <andrey@sitnik.ru>
+
+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.

package/dist/compiled/nanoid/package.json

@@ -0,0 +1 @@
+{"name":"nanoid","author":"Andrey Sitnik <andrey@sitnik.ru>","version":"3.3.11","funding":[{"type":"github","url":"https://github.com/sponsors/ai"}],"license":"MIT","types":"./index.d.ts","main":"index.js","module":"index.mjs"}