/*
 * Beautified version of:
 * hash-wasm (https://www.npmjs.com/package/hash-wasm)
 * (c) Dani Biro
 * @license MIT
 */

! function(A, I) {
    "object" == typeof exports && "undefined" != typeof module ? I(exports) : "function" == typeof define && define.amd ? define(["exports"], I) : I((A = "undefined" != typeof globalThis ? globalThis : A || self).hashwasm = {})
}(this, (function(A) {
    "use strict";

    function I(A, I, B, g) {
        return new(B || (B = Promise))((function(Q, C) {
            function i(A) {
                try {
                    o(g.next(A))
                } catch (A) {
                    C(A)
                }
            }

            function E(A) {
                try {
                    o(g.throw(A))
                } catch (A) {
                    C(A)
                }
            }

            function o(A) {
                var I;
                A.done ? Q(A.value) : (I = A.value, I instanceof B ? I : new B((function(A) {
                    A(I)
                }))).then(i, E)
            }
            o((g = g.apply(A, I || [])).next())
        }))
    }
    "function" == typeof SuppressedError && SuppressedError;
    class B {
        constructor() {
            this.mutex = Promise.resolve()
        }
        lock() {
            let A = () => {};
            return this.mutex = this.mutex.then((() => new Promise(A))), new Promise((I => {
                A = I
            }))
        }
        dispatch(A) {
            return I(this, void 0, void 0, (function*() {
                const I = yield this.lock();
                try {
                    return yield Promise.resolve(A())
                } finally {
                    I()
                }
            }))
        }
    }
    var g;
    const Q = "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : "undefined" != typeof window ? window : global,
        C = null !== (g = Q.Buffer) && void 0 !== g ? g : null,
        i = Q.TextEncoder ? new Q.TextEncoder : null;

    function E(A, I) {
        return (15 & A) + (A >> 6 | A >> 3 & 8) << 4 | (15 & I) + (I >> 6 | I >> 3 & 8)
    }

    function o(A, I) {
        const B = I.length >> 1;
        for (let g = 0; g < B; g++) {
            const B = g << 1;
            A[g] = E(I.charCodeAt(B), I.charCodeAt(B + 1))
        }
    }
    const F = "a".charCodeAt(0) - 10,
        D = "0".charCodeAt(0);

    function c(A, I, B) {
        let g = 0;
        for (let Q = 0; Q < B; Q++) {
            let B = I[Q] >>> 4;
            A[g++] = B > 9 ? B + F : B + D, B = 15 & I[Q], A[g++] = B > 9 ? B + F : B + D
        }
        return String.fromCharCode.apply(null, A)
    }
    const h = null !== C ? A => {
            if ("string" == typeof A) {
                const I = C.from(A, "utf8");
                return new Uint8Array(I.buffer, I.byteOffset, I.length)
            }
            if (C.isBuffer(A)) return new Uint8Array(A.buffer, A.byteOffset, A.length);
            if (ArrayBuffer.isView(A)) return new Uint8Array(A.buffer, A.byteOffset, A.byteLength);
            throw new Error("Invalid data type!")
        } : A => {
            if ("string" == typeof A) return i.encode(A);
            if (ArrayBuffer.isView(A)) return new Uint8Array(A.buffer, A.byteOffset, A.byteLength);
            throw new Error("Invalid data type!")
        },
        a = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
        w = new Uint8Array(256);
    for (let A = 0; A < a.length; A++) w[a.charCodeAt(A)] = A;

    function k(A, I = !0) {
        const B = A.length,
            g = B % 3,
            Q = [],
            C = B - g;
        for (let I = 0; I < C; I += 3) {
            const B = (A[I] << 16 & 16711680) + (A[I + 1] << 8 & 65280) + (255 & A[I + 2]),
                g = a.charAt(B >> 18 & 63) + a.charAt(B >> 12 & 63) + a.charAt(B >> 6 & 63) + a.charAt(63 & B);
            Q.push(g)
        }
        if (1 === g) {
            const g = A[B - 1],
                C = a.charAt(g >> 2),
                i = a.charAt(g << 4 & 63);
            Q.push(`${C}${i}`), I && Q.push("==")
        } else if (2 === g) {
            const g = (A[B - 2] << 8) + A[B - 1],
                C = a.charAt(g >> 10),
                i = a.charAt(g >> 4 & 63),
                E = a.charAt(g << 2 & 63);
            Q.push(`${C}${i}${E}`), I && Q.push("=")
        }
        return Q.join("")
    }

    function G(A) {
        let I = Math.floor(.75 * A.length);
        const B = A.length;
        return "=" === A[B - 1] && (I -= 1, "=" === A[B - 2] && (I -= 1)), I
    }

    function H(A) {
        const I = G(A),
            B = A.length,
            g = new Uint8Array(I);
        let Q = 0;
        for (let I = 0; I < B; I += 4) {
            const B = w[A.charCodeAt(I)],
                C = w[A.charCodeAt(I + 1)],
                i = w[A.charCodeAt(I + 2)],
                E = w[A.charCodeAt(I + 3)];
            g[Q] = B << 2 | C >> 4, Q += 1, g[Q] = (15 & C) << 4 | i >> 2, Q += 1, g[Q] = (3 & i) << 6 | 63 & E, Q += 1
        }
        return g
    }
    const n = 16384,
        d = new B,
        y = new Map;

    function U(A, B) {
        return I(this, void 0, void 0, (function*() {
            let g = null,
                Q = null,
                C = !1;
            if ("undefined" == typeof WebAssembly) throw new Error("WebAssembly is not supported in this environment!");
            const i = () => new DataView(g.exports.memory.buffer).getUint32(g.exports.STATE_SIZE, !0),
                F = d.dispatch((() => I(this, void 0, void 0, (function*() {
                    if (!y.has(A.name)) {
                        const I = H(A.data),
                            B = WebAssembly.compile(I);
                        y.set(A.name, B)
                    }
                    const I = yield y.get(A.name);
                    g = yield WebAssembly.instantiate(I, {})
                })))),
                D = (A = null) => {
                    C = !0, g.exports.Hash_Init(A)
                },
                a = A => {
                    if (!C) throw new Error("update() called before init()");
                    (A => {
                        let I = 0;
                        for (; I < A.length;) {
                            const B = A.subarray(I, I + n);
                            I += B.length, Q.set(B), g.exports.Hash_Update(B.length)
                        }
                    })(h(A))
                },
                w = new Uint8Array(2 * B),
                k = (A, I = null) => {
                    if (!C) throw new Error("digest() called before init()");
                    return C = !1, g.exports.Hash_Final(I), "binary" === A ? Q.slice(0, B) : c(w, Q, B)
                },
                G = A => "string" == typeof A ? A.length < 4096 : A.byteLength < n;
            let U = G;
            switch (A.name) {
                case "argon2":
                case "scrypt":
                    U = () => !0;
                    break;
                case "blake2b":
                case "blake2s":
                    U = (A, I) => I <= 512 && G(A);
                    break;
                case "blake3":
                    U = (A, I) => 0 === I && G(A);
                    break;
                case "xxhash64":
                case "xxhash3":
                case "xxhash128":
                    U = () => !1
            }
            return yield(() => I(this, void 0, void 0, (function*() {
                g || (yield F);
                const A = g.exports.Hash_GetBuffer(),
                    I = g.exports.memory.buffer;
                Q = new Uint8Array(I, A, n)
            })))(), {
                getMemory: () => Q,
                writeMemory: (A, I = 0) => {
                    Q.set(A, I)
                },
                getExports: () => g.exports,
                setMemorySize: A => {
                    g.exports.Hash_SetMemorySize(A);
                    const I = g.exports.Hash_GetBuffer(),
                        B = g.exports.memory.buffer;
                    Q = new Uint8Array(B, I, A)
                },
                init: D,
                update: a,
                digest: k,
                save: () => {
                    if (!C) throw new Error("save() can only be called after init() and before digest()");
                    const I = g.exports.Hash_GetState(),
                        B = i(),
                        Q = g.exports.memory.buffer,
                        E = new Uint8Array(Q, I, B),
                        F = new Uint8Array(4 + B);
                    return o(F, A.hash), F.set(E, 4), F
                },
                load: I => {
                    if (!(I instanceof Uint8Array)) throw new Error("load() expects an Uint8Array generated by save()");
                    const B = g.exports.Hash_GetState(),
                        Q = i(),
                        o = 4 + Q,
                        F = g.exports.memory.buffer;
                    if (I.length !== o) throw new Error(`Bad state length (expected ${o} bytes, got ${I.length})`);
                    if (! function(A, I) {
                            if (A.length !== 2 * I.length) return !1;
                            for (let B = 0; B < I.length; B++) {
                                const g = B << 1;
                                if (I[B] !== E(A.charCodeAt(g), A.charCodeAt(g + 1))) return !1
                            }
                            return !0
                        }(A.hash, I.subarray(0, 4))) throw new Error("This state was written by an incompatible hash implementation");
                    const D = I.subarray(4);
                    new Uint8Array(F, B, Q).set(D), C = !0
                },
                calculate: (A, I = null, C = null) => {
                    if (!U(A, I)) return D(I), a(A), k("hex", C);
                    const i = h(A);
                    return Q.set(i), g.exports.Hash_Calculate(i.length, I, C), c(w, Q, B)
                },
                hashLength: B
            }
        }))
    }
    var e = {
        name: "adler32",
        data: "AGFzbQEAAAABDANgAAF/YAAAYAF/AAMHBgABAgEAAgUEAQECAgYOAn8BQYCJBQt/AEGACAsHcAgGbWVtb3J5AgAOSGFzaF9HZXRCdWZmZXIAAAlIYXNoX0luaXQAAQtIYXNoX1VwZGF0ZQACCkhhc2hfRmluYWwAAw1IYXNoX0dldFN0YXRlAAQOSGFzaF9DYWxjdWxhdGUABQpTVEFURV9TSVpFAwEK6wkGBQBBgAkLCgBBAEEBNgKECAvjCAEHf0EAKAKECCIBQf//A3EhAiABQRB2IQMCQAJAIABBAUcNACACQQAtAIAJaiIBQY+AfGogASABQfD/A0sbIgEgA2oiBEEQdCIFQYCAPGogBSAEQfD/A0sbIAFyIQEMAQsCQAJAAkACQAJAIABBEEkNAEGACSEGIABBsCtJDQFBgAkhBgNAQQAhBQNAIAYgBWoiASgCACIEQf8BcSACaiICIANqIAIgBEEIdkH/AXFqIgJqIAIgBEEQdkH/AXFqIgJqIAIgBEEYdmoiAmogAiABQQRqKAIAIgRB/wFxaiICaiACIARBCHZB/wFxaiICaiACIARBEHZB/wFxaiICaiACIARBGHZqIgJqIAIgAUEIaigCACIEQf8BcWoiAmogAiAEQQh2Qf8BcWoiAmogAiAEQRB2Qf8BcWoiAmogAiAEQRh2aiIEaiAEIAFBDGooAgAiAUH/AXFqIgRqIAQgAUEIdkH/AXFqIgRqIAQgAUEQdkH/AXFqIgRqIAQgAUEYdmoiAmohAyAFQRBqIgVBsCtHDQALIANB8f8DcCEDIAJB8f8DcCECIAZBsCtqIQYgAEHQVGoiAEGvK0sNAAsgAEUNBCAAQQ9LDQEMAgsCQCAARQ0AAkACQCAAQQNxIgUNAEGACSEBIAAhBAwBCyAAQXxxIQRBACEBA0AgAiABQYAJai0AAGoiAiADaiEDIAUgAUEBaiIBRw0ACyAFQYAJaiEBCyAAQQRJDQADQCACIAEtAABqIgUgAS0AAWoiBiABLQACaiIAIAFBA2otAABqIgIgACAGIAUgA2pqamohAyABQQRqIQEgBEF8aiIEDQALCyACQY+AfGogAiACQfD/A0sbIANB8f8DcEEQdHIhAQwECwNAIAYoAgAiAUH/AXEgAmoiBCADaiAEIAFBCHZB/wFxaiIEaiAEIAFBEHZB/wFxaiIEaiAEIAFBGHZqIgRqIAQgBkEEaigCACIBQf8BcWoiBGogBCABQQh2Qf8BcWoiBGogBCABQRB2Qf8BcWoiBGogBCABQRh2aiIEaiAEIAZBCGooAgAiAUH/AXFqIgRqIAQgAUEIdkH/AXFqIgRqIAQgAUEQdkH/AXFqIgRqIAQgAUEYdmoiBGogBCAGQQxqKAIAIgFB/wFxaiIEaiAEIAFBCHZB/wFxaiIEaiAEIAFBEHZB/wFxaiIEaiAEIAFBGHZqIgJqIQMgBkEQaiEGIABBcGoiAEEPSw0ACyAARQ0BCyAAQX9qIQcCQCAAQQNxIgVFDQAgAEF8cSEAIAUhBCAGIQEDQCACIAEtAABqIgIgA2ohAyABQQFqIQEgBEF/aiIEDQALIAYgBWohBgsgB0EDSQ0AA0AgAiAGLQAAaiIBIAYtAAFqIgQgBi0AAmoiBSAGQQNqLQAAaiICIAUgBCABIANqampqIQMgBkEEaiEGIABBfGoiAA0ACwsgA0Hx/wNwIQMgAkHx/wNwIQILIAIgA0EQdHIhAQtBACABNgKECAsxAQF/QQBBACgChAgiAEEYdCAAQYD+A3FBCHRyIABBCHZBgP4DcSAAQRh2cnI2AoAJCwUAQYQICzsAQQBBATYChAggABACQQBBACgChAgiAEEYdCAAQYD+A3FBCHRyIABBCHZBgP4DcSAAQRh2cnI2AoAJCwsVAgBBgAgLBAQAAAAAQYQICwQBAAAA",
        hash: "02ddbd17"
    };

    function N(A, B, g) {
        return I(this, void 0, void 0, (function*() {
            const I = yield A.lock(), Q = yield U(B, g);
            return I(), Q
        }))
    }
    const t = new B;
    let S = null;
    var J = {
        name: "blake2b",
        data: "[encoded data, 9924 characters]",
        hash: "656e0f66"
    };
    const q = new B;
    let f = null;

    function p(A) {
        return !Number.isInteger(A) || A < 8 || A > 512 || A % 8 != 0 ? new Error("Invalid variant! Valid values: 8, 16, ..., 512") : null
    }

    function K(A, I) {
        return A | I << 16
    }

    function M(A = 512, I = null) {
        if (p(A)) return Promise.reject(p(A));
        let B = null,
            g = A;
        if (null !== I) {
            if (B = h(I), B.length > 64) return Promise.reject(new Error("Max key length is 64 bytes"));
            g = K(A, B.length)
        }
        const Q = A / 8;
        return U(J, Q).then((A => {
            g > 512 && A.writeMemory(B), A.init(g);
            const I = {
                init: g > 512 ? () => (A.writeMemory(B), A.init(g), I) : () => (A.init(g), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 128,
                digestSize: Q
            };
            return I
        }))
    }
    var r = {
        name: "argon2",
        data: "[encoded data, 8892 characters]",
        hash: "7ab14c91"
    };
    const s = new DataView(new ArrayBuffer(4));

    function Y(A) {
        return s.setInt32(0, A, !0), new Uint8Array(s.buffer)
    }

    function R(A, B, g) {
        return I(this, void 0, void 0, (function*() {
            if (g <= 64) {
                const A = yield M(8 * g);
                return A.update(Y(g)), A.update(B), A.digest("binary")
            }
            const I = Math.ceil(g / 32) - 2,
                Q = new Uint8Array(g);
            A.init(), A.update(Y(g)), A.update(B);
            let C = A.digest("binary");
            Q.set(C.subarray(0, 32), 0);
            for (let B = 1; B < I; B++) A.init(), A.update(C), C = A.digest("binary"), Q.set(C.subarray(0, 32), 32 * B);
            const i = g - 32 * I;
            let E;
            return 64 === i ? (E = A, E.init()) : E = yield M(8 * i), E.update(C), C = E.digest("binary"), Q.set(C.subarray(0, i), 32 * I), Q
        }))
    }

    function l(A) {
        var B;
        return I(this, void 0, void 0, (function*() {
            const {
                parallelism: I,
                iterations: g,
                hashLength: Q
            } = A, C = h(A.password), i = h(A.salt), E = function(A) {
                switch (A) {
                    case "d":
                        return 0;
                    case "i":
                        return 1;
                    default:
                        return 2
                }
            }(A.hashType), {
                memorySize: F
            } = A, D = h(null !== (B = A.secret) && void 0 !== B ? B : ""), [a, w] = yield Promise.all([U(r, 1024), M(512)]);
            a.setMemorySize(1024 * F + 1024);
            const G = new Uint8Array(24),
                H = new DataView(G.buffer);
            H.setInt32(0, I, !0), H.setInt32(4, Q, !0), H.setInt32(8, F, !0), H.setInt32(12, g, !0), H.setInt32(16, 19, !0), H.setInt32(20, E, !0), a.writeMemory(G, 1024 * F), w.init(), w.update(G), w.update(Y(C.length)), w.update(C), w.update(Y(i.length)), w.update(i), w.update(Y(D.length)), w.update(D), w.update(Y(0));
            const n = 4 * Math.floor(F / (4 * I)),
                d = new Uint8Array(72),
                y = w.digest("binary");
            d.set(y);
            for (let A = 0; A < I; A++) {
                d.set(Y(0), 64), d.set(Y(A), 68);
                let I = A * n,
                    B = yield R(w, d, 1024);
                a.writeMemory(B, 1024 * I), I += 1, d.set(Y(1), 64), B = yield R(w, d, 1024), a.writeMemory(B, 1024 * I)
            }
            const e = new Uint8Array(1024);
            o(e, a.calculate(new Uint8Array([]), F));
            const N = yield R(w, e, Q);
            if ("hex" === A.outputType) {
                return c(new Uint8Array(2 * Q), N, Q)
            }
            return "encoded" === A.outputType ? function(A, I, B) {
                const g = [`m=${I.memorySize}`, `t=${I.iterations}`, `p=${I.parallelism}`].join(",");
                return `$argon2${I.hashType}$v=19$${g}$${k(A,!1)}$${k(B,!1)}`
            }(i, A, N) : N
        }))
    }
    const X = A => {
        var I;
        if (!A || "object" != typeof A) throw new Error("Invalid options parameter. It requires an object.");
        if (!A.password) throw new Error("Password must be specified");
        if (A.password = h(A.password), A.password.length < 1) throw new Error("Password must be specified");
        if (!A.salt) throw new Error("Salt must be specified");
        if (A.salt = h(A.salt), A.salt.length < 8) throw new Error("Salt should be at least 8 bytes long");
        if (A.secret = h(null !== (I = A.secret) && void 0 !== I ? I : ""), !Number.isInteger(A.iterations) || A.iterations < 1) throw new Error("Iterations should be a positive number");
        if (!Number.isInteger(A.parallelism) || A.parallelism < 1) throw new Error("Parallelism should be a positive number");
        if (!Number.isInteger(A.hashLength) || A.hashLength < 4) throw new Error("Hash length should be at least 4 bytes.");
        if (!Number.isInteger(A.memorySize)) throw new Error("Memory size should be specified.");
        if (A.memorySize < 8 * A.parallelism) throw new Error("Memory size should be at least 8 * parallelism.");
        if (void 0 === A.outputType && (A.outputType = "hex"), !["hex", "binary", "encoded"].includes(A.outputType)) throw new Error(`Insupported output type ${A.outputType}. Valid values: ['hex', 'binary', 'encoded']`)
    };
    var z = {
        name: "blake2s",
        data: "[encoded data, 8868 characters]",
        hash: "c5c746d4"
    };
    const Z = new B;
    let V = null;

    function L(A) {
        return !Number.isInteger(A) || A < 8 || A > 256 || A % 8 != 0 ? new Error("Invalid variant! Valid values: 8, 16, ..., 256") : null
    }

    function m(A, I) {
        return A | I << 16
    }
    var O = {
        name: "blake3",
        data: "[encoded data, 15872 characters]",
        hash: "540e8b8e"
    };
    const x = new B;
    let W = null;

    function u(A) {
        return !Number.isInteger(A) || A < 8 || A % 8 != 0 ? new Error("Invalid variant! Valid values: 8, 16, ...") : null
    }
    var P = {
        name: "crc32",
        data: "AGFzbQEAAAABEQRgAAF/YAF/AGAAAGACf38AAwgHAAEBAQIAAwUEAQECAgYOAn8BQZDJBQt/AEGACAsHcAgGbWVtb3J5AgAOSGFzaF9HZXRCdWZmZXIAAAlIYXNoX0luaXQAAgtIYXNoX1VwZGF0ZQADCkhhc2hfRmluYWwABA1IYXNoX0dldFN0YXRlAAUOSGFzaF9DYWxjdWxhdGUABgpTVEFURV9TSVpFAwEKkggHBQBBgAkLwwMBA39BgIkBIQFBACECA0AgAUEAQQBBAEEAQQBBAEEAQQAgAkEBcWsgAHEgAkEBdnMiA0EBcWsgAHEgA0EBdnMiA0EBcWsgAHEgA0EBdnMiA0EBcWsgAHEgA0EBdnMiA0EBcWsgAHEgA0EBdnMiA0EBcWsgAHEgA0EBdnMiA0EBcWsgAHEgA0EBdnMiA0EBcWsgAHEgA0EBdnM2AgAgAUEEaiEBIAJBAWoiAkGAAkcNAAtBACEAA0AgAEGEkQFqIABBhIkBaigCACICQf8BcUECdEGAiQFqKAIAIAJBCHZzIgI2AgAgAEGEmQFqIAJB/wFxQQJ0QYCJAWooAgAgAkEIdnMiAjYCACAAQYShAWogAkH/AXFBAnRBgIkBaigCACACQQh2cyICNgIAIABBhKkBaiACQf8BcUECdEGAiQFqKAIAIAJBCHZzIgI2AgAgAEGEsQFqIAJB/wFxQQJ0QYCJAWooAgAgAkEIdnMiAjYCACAAQYS5AWogAkH/AXFBAnRBgIkBaigCACACQQh2cyICNgIAIABBhMEBaiACQf8BcUECdEGAiQFqKAIAIAJBCHZzNgIAIABBBGoiAEH8B0cNAAsLJwACQEEAKAKAyQEgAEYNACAAEAFBACAANgKAyQELQQBBADYChMkBC4gDAQN/QQAoAoTJAUF/cyEBQYAJIQICQCAAQQhJDQBBgAkhAgNAIAJBBGooAgAiA0EOdkH8B3FBgJEBaigCACADQRZ2QfwHcUGAiQFqKAIAcyADQQZ2QfwHcUGAmQFqKAIAcyADQf8BcUECdEGAoQFqKAIAcyACKAIAIAFzIgFBFnZB/AdxQYCpAWooAgBzIAFBDnZB/AdxQYCxAWooAgBzIAFBBnZB/AdxQYC5AWooAgBzIAFB/wFxQQJ0QYDBAWooAgBzIQEgAkEIaiECIABBeGoiAEEHSw0ACwsCQCAARQ0AAkACQCAAQQFxDQAgACEDDAELIAFB/wFxIAItAABzQQJ0QYCJAWooAgAgAUEIdnMhASACQQFqIQIgAEF/aiEDCyAAQQFGDQADQCABQf8BcSACLQAAc0ECdEGAiQFqKAIAIAFBCHZzIgFB/wFxIAJBAWotAABzQQJ0QYCJAWooAgAgAUEIdnMhASACQQJqIQIgA0F+aiIDDQALC0EAIAFBf3M2AoTJAQsyAQF/QQBBACgChMkBIgBBGHQgAEGA/gNxQQh0ciAAQQh2QYD+A3EgAEEYdnJyNgKACQsGAEGEyQELWQACQEEAKAKAyQEgAUYNACABEAFBACABNgKAyQELQQBBADYChMkBIAAQA0EAQQAoAoTJASIBQRh0IAFBgP4DcUEIdHIgAUEIdkGA/gNxIAFBGHZycjYCgAkLCwsBAEGACAsEBAAAAA==",
        hash: "d2eba587"
    };
    const b = new B;
    let T = null;
    const v = new B;
    let j = null;
    var $ = {
        name: "md4",
        data: "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",
        hash: "74909c24"
    };
    const _ = new B;
    let AA = null;
    var IA = {
        name: "md5",
        data: "[encoded data, 4704 characters]",
        hash: "42fa4d29"
    };
    const BA = new B;
    let gA = null;
    var QA = {
        name: "sha1",
        data: "[encoded data, 7456 characters]",
        hash: "6b530c24"
    };
    const CA = new B;
    let iA = null;
    var EA = {
        name: "sha3",
        data: "[encoded data, 5364 characters]",
        hash: "f2f6f5b2"
    };
    const oA = new B;
    let FA = null;

    function DA(A) {
        return [224, 256, 384, 512].includes(A) ? null : new Error("Invalid variant! Valid values: 224, 256, 384, 512")
    }
    const cA = new B;
    let hA = null;

    function aA(A) {
        return [224, 256, 384, 512].includes(A) ? null : new Error("Invalid variant! Valid values: 224, 256, 384, 512")
    }
    var wA = {
        name: "sha256",
        data: "[encoded data, 12924 characters]",
        hash: "64f06674"
    };
    const kA = new B;
    let GA = null;
    const HA = new B;
    let nA = null;

    function dA() {
        return U(wA, 32).then((A => {
            A.init(256);
            const I = {
                init: () => (A.init(256), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 64,
                digestSize: 32
            };
            return I
        }))
    }
    var yA = {
        name: "sha512",
        data: "[encoded data, 18036 characters]",
        hash: "cdd57f6a"
    };
    const UA = new B;
    let eA = null;
    const NA = new B;
    let tA = null;
    var SA = {
        name: "xxhash32",
        data: "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",
        hash: "9e3a00cd"
    };
    const JA = new B;
    let qA = null;

    function fA(A) {
        return !Number.isInteger(A) || A < 0 || A > 4294967295 ? new Error("Seed must be a valid 32-bit long unsigned integer.") : null
    }
    var pA = {
        name: "xxhash64",
        data: "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",
        hash: "dc61b4e7"
    };
    const KA = new B;
    let MA = null;
    const rA = new ArrayBuffer(8);

    function sA(A) {
        return !Number.isInteger(A) || A < 0 || A > 4294967295 ? new Error("Seed must be given as two valid 32-bit long unsigned integers (lo + high).") : null
    }

    function YA(A, I, B) {
        const g = new DataView(A);
        g.setUint32(0, I, !0), g.setUint32(4, B, !0)
    }
    var RA = {
        name: "xxhash3",
        data: "[encoded data, 11932 characters]",
        hash: "0dca92d1"
    };
    const lA = new B;
    let XA = null;
    const zA = new ArrayBuffer(8);

    function ZA(A) {
        return !Number.isInteger(A) || A < 0 || A > 4294967295 ? new Error("Seed must be given as two valid 32-bit long unsigned integers (lo + high).") : null
    }

    function VA(A, I, B) {
        const g = new DataView(A);
        g.setUint32(0, I, !0), g.setUint32(4, B, !0)
    }
    var LA = {
        name: "xxhash128",
        data: "[encoded data, 13840 characters]",
        hash: "1f682d91"
    };
    const mA = new B;
    let OA = null;
    const xA = new ArrayBuffer(8);

    function WA(A) {
        return !Number.isInteger(A) || A < 0 || A > 4294967295 ? new Error("Seed must be given as two valid 32-bit long unsigned integers (lo + high).") : null
    }

    function uA(A, I, B) {
        const g = new DataView(A);
        g.setUint32(0, I, !0), g.setUint32(4, B, !0)
    }
    var PA = {
        name: "ripemd160",
        data: "[encoded data, 9020 characters]",
        hash: "c089a7ca"
    };
    const bA = new B;
    let TA = null;

    function vA(A, I) {
        A.init();
        const {
            blockSize: B
        } = A, g = function(A, I) {
            const {
                blockSize: B
            } = A, g = h(I);
            if (g.length > B) {
                A.update(g);
                const I = A.digest("binary");
                return A.init(), I
            }
            return new Uint8Array(g.buffer, g.byteOffset, g.length)
        }(A, I), Q = new Uint8Array(B);
        Q.set(g);
        const C = new Uint8Array(B);
        for (let A = 0; A < B; A++) {
            const I = Q[A];
            C[A] = 92 ^ I, Q[A] = 54 ^ I
        }
        A.update(Q);
        const i = {
            init: () => (A.init(), A.update(Q), i),
            update: I => (A.update(I), i),
            digest: I => {
                const B = A.digest("binary");
                return A.init(), A.update(C), A.update(B), A.digest(I)
            },
            save: () => {
                throw new Error("save() not supported")
            },
            load: () => {
                throw new Error("load() not supported")
            },
            blockSize: A.blockSize,
            digestSize: A.digestSize
        };
        return i
    }

    function jA(A, I) {
        if (!A || !A.then) throw new Error('Invalid hash function is provided! Usage: createHMAC(createMD5(), "key").');
        return A.then((A => vA(A, I)))
    }

    function $A(A) {
        return I(this, void 0, void 0, (function*() {
            (A => {
                if (!A || "object" != typeof A) throw new Error("Invalid options parameter. It requires an object.");
                if (!A.hashFunction || !A.hashFunction.then) throw new Error('Invalid hash function is provided! Usage: pbkdf2("password", "salt", 1000, 32, createSHA1()).');
                if (!Number.isInteger(A.iterations) || A.iterations < 1) throw new Error("Iterations should be a positive number");
                if (!Number.isInteger(A.hashLength) || A.hashLength < 1) throw new Error("Hash length should be a positive number");
                if (void 0 === A.outputType && (A.outputType = "hex"), !["hex", "binary"].includes(A.outputType)) throw new Error(`Insupported output type ${A.outputType}. Valid values: ['hex', 'binary']`)
            })(A);
            return function(A, B, g, Q, C) {
                return I(this, void 0, void 0, (function*() {
                    const I = new Uint8Array(Q),
                        i = new Uint8Array(B.length + 4),
                        E = new DataView(i.buffer),
                        o = h(B),
                        F = new Uint8Array(o.buffer, o.byteOffset, o.length);
                    i.set(F);
                    let D = 0;
                    const a = A.digestSize,
                        w = Math.ceil(Q / a);
                    let k = null,
                        G = null;
                    for (let C = 1; C <= w; C++) {
                        E.setUint32(B.length, C), A.init(), A.update(i), k = A.digest("binary"), G = k.slice();
                        for (let I = 1; I < g; I++) {
                            A.init(), A.update(G), G = A.digest("binary");
                            for (let A = 0; A < a; A++) k[A] ^= G[A]
                        }
                        I.set(k.subarray(0, Q - D), D), D += a
                    }
                    return "binary" === C ? I : c(new Uint8Array(2 * Q), I, Q)
                }))
            }(yield jA(A.hashFunction, A.password), A.salt, A.iterations, A.hashLength, A.outputType)
        }))
    }
    var _A = {
        name: "scrypt",
        data: "[encoded data, 6748 characters]",
        hash: "c51b8bf7"
    };
    var AI = {
        name: "bcrypt",
        data: "[encoded data, 22596 characters]",
        hash: "497b89b2"
    };

    function II(A) {
        return I(this, void 0, void 0, (function*() {
            const {
                costFactor: I,
                password: B,
                salt: g
            } = A, Q = yield U(AI, 0);
            Q.writeMemory(h(g), 0);
            const C = h(B);
            Q.writeMemory(C, 16);
            const i = "encoded" === A.outputType ? 1 : 0;
            Q.getExports().bcrypt(C.length, I, i);
            const E = Q.getMemory();
            if ("encoded" === A.outputType) return o = E, F = 60, String.fromCharCode(...o.subarray(0, F));
            var o, F;
            if ("hex" === A.outputType) {
                return c(new Uint8Array(48), E, 24)
            }
            return E.slice(0, 24)
        }))
    }
    const BI = A => {
        if (!A || "object" != typeof A) throw new Error("Invalid options parameter. It requires an object.");
        if (void 0 === A.hash || "string" != typeof A.hash) throw new Error("Hash should be specified");
        if (60 !== A.hash.length) throw new Error("Hash should be 60 bytes long");
        if (!(A => !(!/^\$2[axyb]\$[0-3][0-9]\$[./A-Za-z0-9]{53}$/.test(A) || "0" === A[4] && parseInt(A[5], 10) < 4 || "3" === A[4] && parseInt(A[5], 10) > 1))(A.hash)) throw new Error("Invalid hash");
        if (A.password = h(A.password), A.password.length < 1) throw new Error("Password should be at least 1 byte long");
        if (A.password.length > 72) throw new Error("Password should be at most 72 bytes long")
    };
    var gI = {
        name: "whirlpool",
        data: "[encoded data, 7756 characters]",
        hash: "dba12019"
    };
    const QI = new B;
    let CI = null;
    var iI = {
        name: "sm3",
        data: "[encoded data, 5408 characters]",
        hash: "56515712"
    };
    const EI = new B;
    let oI = null;
    A.adler32 = function(A) {
        if (null === S) return N(t, e, 4).then((I => (S = I, S.calculate(A))));
        try {
            const I = S.calculate(A);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.argon2Verify = function(A) {
        return I(this, void 0, void 0, (function*() {
            (A => {
                if (!A || "object" != typeof A) throw new Error("Invalid options parameter. It requires an object.");
                if (void 0 === A.hash || "string" != typeof A.hash) throw new Error("Hash should be specified")
            })(A);
            const I = ((A, I, B) => {
                const g = I.match(/^\$argon2(id|i|d)\$v=([0-9]+)\$((?:[mtp]=[0-9]+,){2}[mtp]=[0-9]+)\$([A-Za-z0-9+/]+)\$([A-Za-z0-9+/]+)$/);
                if (!g) throw new Error("Invalid hash");
                const [, Q, C, i, E, o] = g;
                if ("19" !== C) throw new Error(`Unsupported version: ${C}`);
                const F = {},
                    D = {
                        m: "memorySize",
                        p: "parallelism",
                        t: "iterations"
                    };
                return i.split(",").forEach((A => {
                    const [I, B] = A.split("=");
                    F[D[I]] = parseInt(B, 10)
                })), Object.assign(Object.assign({}, F), {
                    password: A,
                    secret: B,
                    hashType: Q,
                    salt: H(E),
                    hashLength: G(o),
                    outputType: "encoded"
                })
            })(A.password, A.hash, A.secret);
            X(I);
            const B = A.hash.lastIndexOf("$") + 1;
            return (yield l(I)).substring(B) === A.hash.substring(B)
        }))
    }, A.argon2d = function(A) {
        return I(this, void 0, void 0, (function*() {
            return X(A), l(Object.assign(Object.assign({}, A), {
                hashType: "d"
            }))
        }))
    }, A.argon2i = function(A) {
        return I(this, void 0, void 0, (function*() {
            return X(A), l(Object.assign(Object.assign({}, A), {
                hashType: "i"
            }))
        }))
    }, A.argon2id = function(A) {
        return I(this, void 0, void 0, (function*() {
            return X(A), l(Object.assign(Object.assign({}, A), {
                hashType: "id"
            }))
        }))
    }, A.bcrypt = function(A) {
        return I(this, void 0, void 0, (function*() {
            return (A => {
                if (!A || "object" != typeof A) throw new Error("Invalid options parameter. It requires an object.");
                if (!Number.isInteger(A.costFactor) || A.costFactor < 4 || A.costFactor > 31) throw new Error("Cost factor should be a number between 4 and 31");
                if (A.password = h(A.password), A.password.length < 1) throw new Error("Password should be at least 1 byte long");
                if (A.password.length > 72) throw new Error("Password should be at most 72 bytes long");
                if (A.salt = h(A.salt), 16 !== A.salt.length) throw new Error("Salt should be 16 bytes long");
                if (void 0 === A.outputType && (A.outputType = "encoded"), !["hex", "binary", "encoded"].includes(A.outputType)) throw new Error(`Insupported output type ${A.outputType}. Valid values: ['hex', 'binary', 'encoded']`)
            })(A), II(A)
        }))
    }, A.bcryptVerify = function(A) {
        return I(this, void 0, void 0, (function*() {
            BI(A);
            const {
                hash: I,
                password: B
            } = A, g = yield U(AI, 0);
            g.writeMemory(h(I), 0);
            const Q = h(B);
            return g.writeMemory(Q, 60), !!g.getExports().bcrypt_verify(Q.length)
        }))
    }, A.blake2b = function(A, I = 512, B = null) {
        if (p(I)) return Promise.reject(p(I));
        let g = null,
            Q = I;
        if (null !== B) {
            if (g = h(B), g.length > 64) return Promise.reject(new Error("Max key length is 64 bytes"));
            Q = K(I, g.length)
        }
        const C = I / 8;
        if (null === f || f.hashLength !== C) return N(q, J, C).then((I => (f = I, Q > 512 && f.writeMemory(g), f.calculate(A, Q))));
        try {
            Q > 512 && f.writeMemory(g);
            const I = f.calculate(A, Q);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.blake2s = function(A, I = 256, B = null) {
        if (L(I)) return Promise.reject(L(I));
        let g = null,
            Q = I;
        if (null !== B) {
            if (g = h(B), g.length > 32) return Promise.reject(new Error("Max key length is 32 bytes"));
            Q = m(I, g.length)
        }
        const C = I / 8;
        if (null === V || V.hashLength !== C) return N(Z, z, C).then((I => (V = I, Q > 512 && V.writeMemory(g), V.calculate(A, Q))));
        try {
            Q > 512 && V.writeMemory(g);
            const I = V.calculate(A, Q);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.blake3 = function(A, I = 256, B = null) {
        if (u(I)) return Promise.reject(u(I));
        let g = null,
            Q = 0;
        if (null !== B) {
            if (g = h(B), 32 !== g.length) return Promise.reject(new Error("Key length must be exactly 32 bytes"));
            Q = 32
        }
        const C = I / 8,
            i = C;
        if (null === W || W.hashLength !== C) return N(x, O, C).then((I => (W = I, 32 === Q && W.writeMemory(g), W.calculate(A, Q, i))));
        try {
            32 === Q && W.writeMemory(g);
            const I = W.calculate(A, Q, i);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.crc32 = function(A) {
        if (null === T) return N(b, P, 4).then((I => (T = I, T.calculate(A, 3988292384))));
        try {
            const I = T.calculate(A, 3988292384);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.crc32c = function(A) {
        if (null === j) return N(v, P, 4).then((I => (j = I, j.calculate(A, 2197175160))));
        try {
            const I = j.calculate(A, 2197175160);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.createAdler32 = function() {
        return U(e, 4).then((A => {
            A.init();
            const I = {
                init: () => (A.init(), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 4,
                digestSize: 4
            };
            return I
        }))
    }, A.createBLAKE2b = M, A.createBLAKE2s = function(A = 256, I = null) {
        if (L(A)) return Promise.reject(L(A));
        let B = null,
            g = A;
        if (null !== I) {
            if (B = h(I), B.length > 32) return Promise.reject(new Error("Max key length is 32 bytes"));
            g = m(A, B.length)
        }
        const Q = A / 8;
        return U(z, Q).then((A => {
            g > 512 && A.writeMemory(B), A.init(g);
            const I = {
                init: g > 512 ? () => (A.writeMemory(B), A.init(g), I) : () => (A.init(g), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 64,
                digestSize: Q
            };
            return I
        }))
    }, A.createBLAKE3 = function(A = 256, I = null) {
        if (u(A)) return Promise.reject(u(A));
        let B = null,
            g = 0;
        if (null !== I) {
            if (B = h(I), 32 !== B.length) return Promise.reject(new Error("Key length must be exactly 32 bytes"));
            g = 32
        }
        const Q = A / 8,
            C = Q;
        return U(O, Q).then((A => {
            32 === g && A.writeMemory(B), A.init(g);
            const I = {
                init: 32 === g ? () => (A.writeMemory(B), A.init(g), I) : () => (A.init(g), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I, C),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 64,
                digestSize: Q
            };
            return I
        }))
    }, A.createCRC32 = function() {
        return U(P, 4).then((A => {
            A.init(3988292384);
            const I = {
                init: () => (A.init(3988292384), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 4,
                digestSize: 4
            };
            return I
        }))
    }, A.createCRC32C = function() {
        return U(P, 4).then((A => {
            A.init(2197175160);
            const I = {
                init: () => (A.init(2197175160), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 4,
                digestSize: 4
            };
            return I
        }))
    }, A.createHMAC = jA, A.createKeccak = function(A = 512) {
        if (aA(A)) return Promise.reject(aA(A));
        const I = A / 8;
        return U(EA, I).then((B => {
            B.init(A);
            const g = {
                init: () => (B.init(A), g),
                update: A => (B.update(A), g),
                digest: A => B.digest(A, 1),
                save: () => B.save(),
                load: A => (B.load(A), g),
                blockSize: 200 - 2 * I,
                digestSize: I
            };
            return g
        }))
    }, A.createMD4 = function() {
        return U($, 16).then((A => {
            A.init();
            const I = {
                init: () => (A.init(), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 64,
                digestSize: 16
            };
            return I
        }))
    }, A.createMD5 = function() {
        return U(IA, 16).then((A => {
            A.init();
            const I = {
                init: () => (A.init(), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 64,
                digestSize: 16
            };
            return I
        }))
    }, A.createRIPEMD160 = function() {
        return U(PA, 20).then((A => {
            A.init();
            const I = {
                init: () => (A.init(), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 64,
                digestSize: 20
            };
            return I
        }))
    }, A.createSHA1 = function() {
        return U(QA, 20).then((A => {
            A.init();
            const I = {
                init: () => (A.init(), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 64,
                digestSize: 20
            };
            return I
        }))
    }, A.createSHA224 = function() {
        return U(wA, 28).then((A => {
            A.init(224);
            const I = {
                init: () => (A.init(224), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 64,
                digestSize: 28
            };
            return I
        }))
    }, A.createSHA256 = dA, A.createSHA3 = function(A = 512) {
        if (DA(A)) return Promise.reject(DA(A));
        const I = A / 8;
        return U(EA, I).then((B => {
            B.init(A);
            const g = {
                init: () => (B.init(A), g),
                update: A => (B.update(A), g),
                digest: A => B.digest(A, 6),
                save: () => B.save(),
                load: A => (B.load(A), g),
                blockSize: 200 - 2 * I,
                digestSize: I
            };
            return g
        }))
    }, A.createSHA384 = function() {
        return U(yA, 48).then((A => {
            A.init(384);
            const I = {
                init: () => (A.init(384), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 128,
                digestSize: 48
            };
            return I
        }))
    }, A.createSHA512 = function() {
        return U(yA, 64).then((A => {
            A.init(512);
            const I = {
                init: () => (A.init(512), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 128,
                digestSize: 64
            };
            return I
        }))
    }, A.createSM3 = function() {
        return U(iI, 32).then((A => {
            A.init();
            const I = {
                init: () => (A.init(), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 64,
                digestSize: 32
            };
            return I
        }))
    }, A.createWhirlpool = function() {
        return U(gI, 64).then((A => {
            A.init();
            const I = {
                init: () => (A.init(), I),
                update: B => (A.update(B), I),
                digest: I => A.digest(I),
                save: () => A.save(),
                load: B => (A.load(B), I),
                blockSize: 64,
                digestSize: 64
            };
            return I
        }))
    }, A.createXXHash128 = function(A = 0, I = 0) {
        return WA(A) ? Promise.reject(WA(A)) : WA(I) ? Promise.reject(WA(I)) : U(LA, 16).then((B => {
            const g = new ArrayBuffer(8);
            uA(g, A, I), B.writeMemory(new Uint8Array(g)), B.init();
            const Q = {
                init: () => (B.writeMemory(new Uint8Array(g)), B.init(), Q),
                update: A => (B.update(A), Q),
                digest: A => B.digest(A),
                save: () => B.save(),
                load: A => (B.load(A), Q),
                blockSize: 512,
                digestSize: 16
            };
            return Q
        }))
    }, A.createXXHash3 = function(A = 0, I = 0) {
        return ZA(A) ? Promise.reject(ZA(A)) : ZA(I) ? Promise.reject(ZA(I)) : U(RA, 8).then((B => {
            const g = new ArrayBuffer(8);
            VA(g, A, I), B.writeMemory(new Uint8Array(g)), B.init();
            const Q = {
                init: () => (B.writeMemory(new Uint8Array(g)), B.init(), Q),
                update: A => (B.update(A), Q),
                digest: A => B.digest(A),
                save: () => B.save(),
                load: A => (B.load(A), Q),
                blockSize: 512,
                digestSize: 8
            };
            return Q
        }))
    }, A.createXXHash32 = function(A = 0) {
        return fA(A) ? Promise.reject(fA(A)) : U(SA, 4).then((I => {
            I.init(A);
            const B = {
                init: () => (I.init(A), B),
                update: A => (I.update(A), B),
                digest: A => I.digest(A),
                save: () => I.save(),
                load: A => (I.load(A), B),
                blockSize: 16,
                digestSize: 4
            };
            return B
        }))
    }, A.createXXHash64 = function(A = 0, I = 0) {
        return sA(A) ? Promise.reject(sA(A)) : sA(I) ? Promise.reject(sA(I)) : U(pA, 8).then((B => {
            const g = new ArrayBuffer(8);
            YA(g, A, I), B.writeMemory(new Uint8Array(g)), B.init();
            const Q = {
                init: () => (B.writeMemory(new Uint8Array(g)), B.init(), Q),
                update: A => (B.update(A), Q),
                digest: A => B.digest(A),
                save: () => B.save(),
                load: A => (B.load(A), Q),
                blockSize: 32,
                digestSize: 8
            };
            return Q
        }))
    }, A.keccak = function(A, I = 512) {
        if (aA(I)) return Promise.reject(aA(I));
        const B = I / 8;
        if (null === hA || hA.hashLength !== B) return N(cA, EA, B).then((B => (hA = B, hA.calculate(A, I, 1))));
        try {
            const B = hA.calculate(A, I, 1);
            return Promise.resolve(B)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.md4 = function(A) {
        if (null === AA) return N(_, $, 16).then((I => (AA = I, AA.calculate(A))));
        try {
            const I = AA.calculate(A);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.md5 = function(A) {
        if (null === gA) return N(BA, IA, 16).then((I => (gA = I, gA.calculate(A))));
        try {
            const I = gA.calculate(A);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.pbkdf2 = $A, A.ripemd160 = function(A) {
        if (null === TA) return N(bA, PA, 20).then((I => (TA = I, TA.calculate(A))));
        try {
            const I = TA.calculate(A);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.scrypt = function(A) {
        return I(this, void 0, void 0, (function*() {
            return (A => {
                    if (!A || "object" != typeof A) throw new Error("Invalid options parameter. It requires an object.");
                    if (!Number.isInteger(A.blockSize) || A.blockSize < 1) throw new Error("Block size should be a positive number");
                    if (!Number.isInteger(A.costFactor) || A.costFactor < 2 || !(I = A.costFactor) || I & I - 1) throw new Error("Cost factor should be a power of 2, greater than 1");
                    var I;
                    if (!Number.isInteger(A.parallelism) || A.parallelism < 1) throw new Error("Parallelism should be a positive number");
                    if (!Number.isInteger(A.hashLength) || A.hashLength < 1) throw new Error("Hash length should be a positive number.");
                    if (void 0 === A.outputType && (A.outputType = "hex"), !["hex", "binary"].includes(A.outputType)) throw new Error(`Insupported output type ${A.outputType}. Valid values: ['hex', 'binary']`)
                })(A),
                function(A) {
                    return I(this, void 0, void 0, (function*() {
                        const {
                            costFactor: I,
                            blockSize: B,
                            parallelism: g,
                            hashLength: Q
                        } = A, C = dA(), i = yield $A({
                            password: A.password,
                            salt: A.salt,
                            iterations: 1,
                            hashLength: 128 * B * g,
                            hashFunction: C,
                            outputType: "binary"
                        }), E = yield U(_A, 0), o = 128 * B * I, F = 256 * B;
                        E.setMemorySize(i.length + o + F), E.writeMemory(i, 0), E.getExports().scrypt(B, I, g);
                        const D = E.getMemory().subarray(0, 128 * B * g),
                            h = yield $A({
                                password: A.password,
                                salt: D,
                                iterations: 1,
                                hashLength: Q,
                                hashFunction: C,
                                outputType: "binary"
                            });
                        return "hex" === A.outputType ? c(new Uint8Array(2 * Q), h, Q) : h
                    }))
                }(A)
        }))
    }, A.sha1 = function(A) {
        if (null === iA) return N(CA, QA, 20).then((I => (iA = I, iA.calculate(A))));
        try {
            const I = iA.calculate(A);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.sha224 = function(A) {
        if (null === GA) return N(kA, wA, 28).then((I => (GA = I, GA.calculate(A, 224))));
        try {
            const I = GA.calculate(A, 224);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.sha256 = function(A) {
        if (null === nA) return N(HA, wA, 32).then((I => (nA = I, nA.calculate(A, 256))));
        try {
            const I = nA.calculate(A, 256);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.sha3 = function(A, I = 512) {
        if (DA(I)) return Promise.reject(DA(I));
        const B = I / 8;
        if (null === FA || FA.hashLength !== B) return N(oA, EA, B).then((B => (FA = B, FA.calculate(A, I, 6))));
        try {
            const B = FA.calculate(A, I, 6);
            return Promise.resolve(B)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.sha384 = function(A) {
        if (null === eA) return N(UA, yA, 48).then((I => (eA = I, eA.calculate(A, 384))));
        try {
            const I = eA.calculate(A, 384);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.sha512 = function(A) {
        if (null === tA) return N(NA, yA, 64).then((I => (tA = I, tA.calculate(A, 512))));
        try {
            const I = tA.calculate(A, 512);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.sm3 = function(A) {
        if (null === oI) return N(EI, iI, 32).then((I => (oI = I, oI.calculate(A))));
        try {
            const I = oI.calculate(A);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.whirlpool = function(A) {
        if (null === CI) return N(QI, gI, 64).then((I => (CI = I, CI.calculate(A))));
        try {
            const I = CI.calculate(A);
            return Promise.resolve(I)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.xxhash128 = function(A, I = 0, B = 0) {
        if (WA(I)) return Promise.reject(WA(I));
        if (WA(B)) return Promise.reject(WA(B));
        if (null === OA) return N(mA, LA, 16).then((g => (OA = g, uA(xA, I, B), OA.writeMemory(new Uint8Array(xA)), OA.calculate(A))));
        try {
            uA(xA, I, B), OA.writeMemory(new Uint8Array(xA));
            const g = OA.calculate(A);
            return Promise.resolve(g)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.xxhash3 = function(A, I = 0, B = 0) {
        if (ZA(I)) return Promise.reject(ZA(I));
        if (ZA(B)) return Promise.reject(ZA(B));
        if (null === XA) return N(lA, RA, 8).then((g => (XA = g, VA(zA, I, B), XA.writeMemory(new Uint8Array(zA)), XA.calculate(A))));
        try {
            VA(zA, I, B), XA.writeMemory(new Uint8Array(zA));
            const g = XA.calculate(A);
            return Promise.resolve(g)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.xxhash32 = function(A, I = 0) {
        if (fA(I)) return Promise.reject(fA(I));
        if (null === qA) return N(JA, SA, 4).then((B => (qA = B, qA.calculate(A, I))));
        try {
            const B = qA.calculate(A, I);
            return Promise.resolve(B)
        } catch (A) {
            return Promise.reject(A)
        }
    }, A.xxhash64 = function(A, I = 0, B = 0) {
        if (sA(I)) return Promise.reject(sA(I));
        if (sA(B)) return Promise.reject(sA(B));
        if (null === MA) return N(KA, pA, 8).then((g => (MA = g, YA(rA, I, B), MA.writeMemory(new Uint8Array(rA)), MA.calculate(A))));
        try {
            YA(rA, I, B), MA.writeMemory(new Uint8Array(rA));
            const g = MA.calculate(A);
            return Promise.resolve(g)
        } catch (A) {
            return Promise.reject(A)
        }
    }
}));