(function (fe, Ce) {
    typeof exports == "object" && typeof module < "u" ? Ce(exports) : typeof define == "function" && define.amd ? define(["exports"], Ce) : (fe = typeof globalThis < "u" ? globalThis : fe || self, Ce(fe.MV = {}))
})(this, function (fe) {
    "use strict";

    function Ce(e) {
        return e != null && typeof e == "object" && e["@@functional/placeholder"] === !0
    }

    function wn(e) {
        return function n(t) {
            return arguments.length === 0 || Ce(t) ? n : e.apply(this, arguments)
        }
    }

    var cr = wn(function (n) {
        return n === null ? "Null" : n === void 0 ? "Undefined" : Object.prototype.toString.call(n).slice(8, -1)
    });

    function fr(e) {
        return new RegExp(e.source, e.flags ? e.flags : (e.global ? "g" : "") + (e.ignoreCase ? "i" : "") + (e.multiline ? "m" : "") + (e.sticky ? "y" : "") + (e.unicode ? "u" : "") + (e.dotAll ? "s" : ""))
    }

    function bn(e, n, t) {
        if (t || (t = new dr), ur(e)) return e;
        var i = function (a) {
            var o = t.get(e);
            if (o) return o;
            t.set(e, a);
            for (var s in e) Object.prototype.hasOwnProperty.call(e, s) && (a[s] = bn(e[s], !0, t));
            return a
        };
        switch (cr(e)) {
            case"Object":
                return i(Object.create(Object.getPrototypeOf(e)));
            case"Array":
                return i(Array(e.length));
            case"Date":
                return new Date(e.valueOf());
            case"RegExp":
                return fr(e);
            case"Int8Array":
            case"Uint8Array":
            case"Uint8ClampedArray":
            case"Int16Array":
            case"Uint16Array":
            case"Int32Array":
            case"Uint32Array":
            case"Float32Array":
            case"Float64Array":
            case"BigInt64Array":
            case"BigUint64Array":
                return e.slice();
            default:
                return e
        }
    }

    function ur(e) {
        var n = typeof e;
        return e == null || n != "object" && n != "function"
    }

    var dr = function () {
        function e() {
            this.map = {}, this.length = 0
        }

        return e.prototype.set = function (n, t) {
            var i = this.hash(n), r = this.map[i];
            r || (this.map[i] = r = []), r.push([n, t]), this.length += 1
        }, e.prototype.hash = function (n) {
            var t = [];
            for (var i in n) t.push(Object.prototype.toString.call(n[i]));
            return t.join()
        }, e.prototype.get = function (n) {
            if (this.length <= 180) {
                for (var t in this.map) for (var o = this.map[t], i = 0; i < o.length; i += 1) {
                    var r = o[i];
                    if (r[0] === n) return r[1]
                }
                return
            }
            var a = this.hash(n), o = this.map[a];
            if (o) for (var i = 0; i < o.length; i += 1) {
                var r = o[i];
                if (r[0] === n) return r[1]
            }
        }, e
    }(), kt = wn(function (n) {
        return n != null && typeof n.clone == "function" ? n.clone() : bn(n)
    });/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
    const hr = 4, yn = 0, xn = 1, _r = 2;

    function xe(e) {
        let n = e.length;
        for (; --n >= 0;) e[n] = 0
    }

    const mr = 0, vn = 1, gr = 2, pr = 3, wr = 258, Rt = 29, Ne = 256, Fe = Ne + 1 + Rt, ve = 30, It = 19,
        En = 2 * Fe + 1, ue = 15, Mt = 16, br = 7, Ot = 256, Sn = 16, An = 17, Tn = 18,
        Dt = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]),
        it = new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]),
        yr = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]),
        kn = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]), xr = 512,
        ee = new Array((Fe + 2) * 2);
    xe(ee);
    const Pe = new Array(ve * 2);
    xe(Pe);
    const Le = new Array(xr);
    xe(Le);
    const Ue = new Array(wr - pr + 1);
    xe(Ue);
    const Ct = new Array(Rt);
    xe(Ct);
    const rt = new Array(ve);
    xe(rt);

    function Nt(e, n, t, i, r) {
        this.static_tree = e, this.extra_bits = n, this.extra_base = t, this.elems = i, this.max_length = r, this.has_stree = e && e.length
    }

    let Rn, In, Mn;

    function Ft(e, n) {
        this.dyn_tree = e, this.max_code = 0, this.stat_desc = n
    }

    const On = e => e < 256 ? Le[e] : Le[256 + (e >>> 7)], ze = (e, n) => {
        e.pending_buf[e.pending++] = n & 255, e.pending_buf[e.pending++] = n >>> 8 & 255
    }, H = (e, n, t) => {
        e.bi_valid > Mt - t ? (e.bi_buf |= n << e.bi_valid & 65535, ze(e, e.bi_buf), e.bi_buf = n >> Mt - e.bi_valid, e.bi_valid += t - Mt) : (e.bi_buf |= n << e.bi_valid & 65535, e.bi_valid += t)
    }, j = (e, n, t) => {
        H(e, t[n * 2], t[n * 2 + 1])
    }, Dn = (e, n) => {
        let t = 0;
        do t |= e & 1, e >>>= 1, t <<= 1; while (--n > 0);
        return t >>> 1
    }, vr = e => {
        e.bi_valid === 16 ? (ze(e, e.bi_buf), e.bi_buf = 0, e.bi_valid = 0) : e.bi_valid >= 8 && (e.pending_buf[e.pending++] = e.bi_buf & 255, e.bi_buf >>= 8, e.bi_valid -= 8)
    }, Er = (e, n) => {
        const t = n.dyn_tree, i = n.max_code, r = n.stat_desc.static_tree, a = n.stat_desc.has_stree,
            o = n.stat_desc.extra_bits, s = n.stat_desc.extra_base, f = n.stat_desc.max_length;
        let l, c, _, h, u, d, p = 0;
        for (h = 0; h <= ue; h++) e.bl_count[h] = 0;
        for (t[e.heap[e.heap_max] * 2 + 1] = 0, l = e.heap_max + 1; l < En; l++) c = e.heap[l], h = t[t[c * 2 + 1] * 2 + 1] + 1, h > f && (h = f, p++), t[c * 2 + 1] = h, !(c > i) && (e.bl_count[h]++, u = 0, c >= s && (u = o[c - s]), d = t[c * 2], e.opt_len += d * (h + u), a && (e.static_len += d * (r[c * 2 + 1] + u)));
        if (p !== 0) {
            do {
                for (h = f - 1; e.bl_count[h] === 0;) h--;
                e.bl_count[h]--, e.bl_count[h + 1] += 2, e.bl_count[f]--, p -= 2
            } while (p > 0);
            for (h = f; h !== 0; h--) for (c = e.bl_count[h]; c !== 0;) _ = e.heap[--l], !(_ > i) && (t[_ * 2 + 1] !== h && (e.opt_len += (h - t[_ * 2 + 1]) * t[_ * 2], t[_ * 2 + 1] = h), c--)
        }
    }, Cn = (e, n, t) => {
        const i = new Array(ue + 1);
        let r = 0, a, o;
        for (a = 1; a <= ue; a++) r = r + t[a - 1] << 1, i[a] = r;
        for (o = 0; o <= n; o++) {
            let s = e[o * 2 + 1];
            s !== 0 && (e[o * 2] = Dn(i[s]++, s))
        }
    }, Sr = () => {
        let e, n, t, i, r;
        const a = new Array(ue + 1);
        for (t = 0, i = 0; i < Rt - 1; i++) for (Ct[i] = t, e = 0; e < 1 << Dt[i]; e++) Ue[t++] = i;
        for (Ue[t - 1] = i, r = 0, i = 0; i < 16; i++) for (rt[i] = r, e = 0; e < 1 << it[i]; e++) Le[r++] = i;
        for (r >>= 7; i < ve; i++) for (rt[i] = r << 7, e = 0; e < 1 << it[i] - 7; e++) Le[256 + r++] = i;
        for (n = 0; n <= ue; n++) a[n] = 0;
        for (e = 0; e <= 143;) ee[e * 2 + 1] = 8, e++, a[8]++;
        for (; e <= 255;) ee[e * 2 + 1] = 9, e++, a[9]++;
        for (; e <= 279;) ee[e * 2 + 1] = 7, e++, a[7]++;
        for (; e <= 287;) ee[e * 2 + 1] = 8, e++, a[8]++;
        for (Cn(ee, Fe + 1, a), e = 0; e < ve; e++) Pe[e * 2 + 1] = 5, Pe[e * 2] = Dn(e, 5);
        Rn = new Nt(ee, Dt, Ne + 1, Fe, ue), In = new Nt(Pe, it, 0, ve, ue), Mn = new Nt(new Array(0), yr, 0, It, br)
    }, Nn = e => {
        let n;
        for (n = 0; n < Fe; n++) e.dyn_ltree[n * 2] = 0;
        for (n = 0; n < ve; n++) e.dyn_dtree[n * 2] = 0;
        for (n = 0; n < It; n++) e.bl_tree[n * 2] = 0;
        e.dyn_ltree[Ot * 2] = 1, e.opt_len = e.static_len = 0, e.sym_next = e.matches = 0
    }, Fn = e => {
        e.bi_valid > 8 ? ze(e, e.bi_buf) : e.bi_valid > 0 && (e.pending_buf[e.pending++] = e.bi_buf), e.bi_buf = 0, e.bi_valid = 0
    }, Pn = (e, n, t, i) => {
        const r = n * 2, a = t * 2;
        return e[r] < e[a] || e[r] === e[a] && i[n] <= i[t]
    }, Pt = (e, n, t) => {
        const i = e.heap[t];
        let r = t << 1;
        for (; r <= e.heap_len && (r < e.heap_len && Pn(n, e.heap[r + 1], e.heap[r], e.depth) && r++, !Pn(n, i, e.heap[r], e.depth));) e.heap[t] = e.heap[r], t = r, r <<= 1;
        e.heap[t] = i
    }, Ln = (e, n, t) => {
        let i, r, a = 0, o, s;
        if (e.sym_next !== 0) do i = e.pending_buf[e.sym_buf + a++] & 255, i += (e.pending_buf[e.sym_buf + a++] & 255) << 8, r = e.pending_buf[e.sym_buf + a++], i === 0 ? j(e, r, n) : (o = Ue[r], j(e, o + Ne + 1, n), s = Dt[o], s !== 0 && (r -= Ct[o], H(e, r, s)), i--, o = On(i), j(e, o, t), s = it[o], s !== 0 && (i -= rt[o], H(e, i, s))); while (a < e.sym_next);
        j(e, Ot, n)
    }, Lt = (e, n) => {
        const t = n.dyn_tree, i = n.stat_desc.static_tree, r = n.stat_desc.has_stree, a = n.stat_desc.elems;
        let o, s, f = -1, l;
        for (e.heap_len = 0, e.heap_max = En, o = 0; o < a; o++) t[o * 2] !== 0 ? (e.heap[++e.heap_len] = f = o, e.depth[o] = 0) : t[o * 2 + 1] = 0;
        for (; e.heap_len < 2;) l = e.heap[++e.heap_len] = f < 2 ? ++f : 0, t[l * 2] = 1, e.depth[l] = 0, e.opt_len--, r && (e.static_len -= i[l * 2 + 1]);
        for (n.max_code = f, o = e.heap_len >> 1; o >= 1; o--) Pt(e, t, o);
        l = a;
        do o = e.heap[1], e.heap[1] = e.heap[e.heap_len--], Pt(e, t, 1), s = e.heap[1], e.heap[--e.heap_max] = o, e.heap[--e.heap_max] = s, t[l * 2] = t[o * 2] + t[s * 2], e.depth[l] = (e.depth[o] >= e.depth[s] ? e.depth[o] : e.depth[s]) + 1, t[o * 2 + 1] = t[s * 2 + 1] = l, e.heap[1] = l++, Pt(e, t, 1); while (e.heap_len >= 2);
        e.heap[--e.heap_max] = e.heap[1], Er(e, n), Cn(t, f, e.bl_count)
    }, Un = (e, n, t) => {
        let i, r = -1, a, o = n[0 * 2 + 1], s = 0, f = 7, l = 4;
        for (o === 0 && (f = 138, l = 3), n[(t + 1) * 2 + 1] = 65535, i = 0; i <= t; i++) a = o, o = n[(i + 1) * 2 + 1], !(++s < f && a === o) && (s < l ? e.bl_tree[a * 2] += s : a !== 0 ? (a !== r && e.bl_tree[a * 2]++, e.bl_tree[Sn * 2]++) : s <= 10 ? e.bl_tree[An * 2]++ : e.bl_tree[Tn * 2]++, s = 0, r = a, o === 0 ? (f = 138, l = 3) : a === o ? (f = 6, l = 3) : (f = 7, l = 4))
    }, zn = (e, n, t) => {
        let i, r = -1, a, o = n[0 * 2 + 1], s = 0, f = 7, l = 4;
        for (o === 0 && (f = 138, l = 3), i = 0; i <= t; i++) if (a = o, o = n[(i + 1) * 2 + 1], !(++s < f && a === o)) {
            if (s < l) do j(e, a, e.bl_tree); while (--s !== 0); else a !== 0 ? (a !== r && (j(e, a, e.bl_tree), s--), j(e, Sn, e.bl_tree), H(e, s - 3, 2)) : s <= 10 ? (j(e, An, e.bl_tree), H(e, s - 3, 3)) : (j(e, Tn, e.bl_tree), H(e, s - 11, 7));
            s = 0, r = a, o === 0 ? (f = 138, l = 3) : a === o ? (f = 6, l = 3) : (f = 7, l = 4)
        }
    }, Ar = e => {
        let n;
        for (Un(e, e.dyn_ltree, e.l_desc.max_code), Un(e, e.dyn_dtree, e.d_desc.max_code), Lt(e, e.bl_desc), n = It - 1; n >= 3 && e.bl_tree[kn[n] * 2 + 1] === 0; n--) ;
        return e.opt_len += 3 * (n + 1) + 5 + 5 + 4, n
    }, Tr = (e, n, t, i) => {
        let r;
        for (H(e, n - 257, 5), H(e, t - 1, 5), H(e, i - 4, 4), r = 0; r < i; r++) H(e, e.bl_tree[kn[r] * 2 + 1], 3);
        zn(e, e.dyn_ltree, n - 1), zn(e, e.dyn_dtree, t - 1)
    }, kr = e => {
        let n = 4093624447, t;
        for (t = 0; t <= 31; t++, n >>>= 1) if (n & 1 && e.dyn_ltree[t * 2] !== 0) return yn;
        if (e.dyn_ltree[9 * 2] !== 0 || e.dyn_ltree[10 * 2] !== 0 || e.dyn_ltree[13 * 2] !== 0) return xn;
        for (t = 32; t < Ne; t++) if (e.dyn_ltree[t * 2] !== 0) return xn;
        return yn
    };
    let Bn = !1;
    const Rr = e => {
            Bn || (Sr(), Bn = !0), e.l_desc = new Ft(e.dyn_ltree, Rn), e.d_desc = new Ft(e.dyn_dtree, In), e.bl_desc = new Ft(e.bl_tree, Mn), e.bi_buf = 0, e.bi_valid = 0, Nn(e)
        }, Hn = (e, n, t, i) => {
            H(e, (mr << 1) + (i ? 1 : 0), 3), Fn(e), ze(e, t), ze(e, ~t), t && e.pending_buf.set(e.window.subarray(n, n + t), e.pending), e.pending += t
        }, Ir = e => {
            H(e, vn << 1, 3), j(e, Ot, ee), vr(e)
        }, Mr = (e, n, t, i) => {
            let r, a, o = 0;
            e.level > 0 ? (e.strm.data_type === _r && (e.strm.data_type = kr(e)), Lt(e, e.l_desc), Lt(e, e.d_desc), o = Ar(e), r = e.opt_len + 3 + 7 >>> 3, a = e.static_len + 3 + 7 >>> 3, a <= r && (r = a)) : r = a = t + 5, t + 4 <= r && n !== -1 ? Hn(e, n, t, i) : e.strategy === hr || a === r ? (H(e, (vn << 1) + (i ? 1 : 0), 3), Ln(e, ee, Pe)) : (H(e, (gr << 1) + (i ? 1 : 0), 3), Tr(e, e.l_desc.max_code + 1, e.d_desc.max_code + 1, o + 1), Ln(e, e.dyn_ltree, e.dyn_dtree)), Nn(e), i && Fn(e)
        },
        Or = (e, n, t) => (e.pending_buf[e.sym_buf + e.sym_next++] = n, e.pending_buf[e.sym_buf + e.sym_next++] = n >> 8, e.pending_buf[e.sym_buf + e.sym_next++] = t, n === 0 ? e.dyn_ltree[t * 2]++ : (e.matches++, n--, e.dyn_ltree[(Ue[t] + Ne + 1) * 2]++, e.dyn_dtree[On(n) * 2]++), e.sym_next === e.sym_end);
    var Dr = Rr, Cr = Hn, Nr = Mr, Fr = Or, Pr = Ir,
        Lr = {_tr_init: Dr, _tr_stored_block: Cr, _tr_flush_block: Nr, _tr_tally: Fr, _tr_align: Pr},
        Be = (e, n, t, i) => {
            let r = e & 65535 | 0, a = e >>> 16 & 65535 | 0, o = 0;
            for (; t !== 0;) {
                o = t > 2e3 ? 2e3 : t, t -= o;
                do r = r + n[i++] | 0, a = a + r | 0; while (--o);
                r %= 65521, a %= 65521
            }
            return r | a << 16 | 0
        };
    const Ur = () => {
        let e, n = [];
        for (var t = 0; t < 256; t++) {
            e = t;
            for (var i = 0; i < 8; i++) e = e & 1 ? 3988292384 ^ e >>> 1 : e >>> 1;
            n[t] = e
        }
        return n
    }, zr = new Uint32Array(Ur());
    var N = (e, n, t, i) => {
        const r = zr, a = i + t;
        e ^= -1;
        for (let o = i; o < a; o++) e = e >>> 8 ^ r[(e ^ n[o]) & 255];
        return e ^ -1
    }, Ee = {
        2: "need dictionary",
        1: "stream end",
        0: "",
        "-1": "file error",
        "-2": "stream error",
        "-3": "data error",
        "-4": "insufficient memory",
        "-5": "buffer error",
        "-6": "incompatible version"
    }, He = {
        Z_NO_FLUSH: 0,
        Z_PARTIAL_FLUSH: 1,
        Z_SYNC_FLUSH: 2,
        Z_FULL_FLUSH: 3,
        Z_FINISH: 4,
        Z_BLOCK: 5,
        Z_TREES: 6,
        Z_OK: 0,
        Z_STREAM_END: 1,
        Z_NEED_DICT: 2,
        Z_ERRNO: -1,
        Z_STREAM_ERROR: -2,
        Z_DATA_ERROR: -3,
        Z_MEM_ERROR: -4,
        Z_BUF_ERROR: -5,
        Z_NO_COMPRESSION: 0,
        Z_BEST_SPEED: 1,
        Z_BEST_COMPRESSION: 9,
        Z_DEFAULT_COMPRESSION: -1,
        Z_FILTERED: 1,
        Z_HUFFMAN_ONLY: 2,
        Z_RLE: 3,
        Z_FIXED: 4,
        Z_DEFAULT_STRATEGY: 0,
        Z_BINARY: 0,
        Z_TEXT: 1,
        Z_UNKNOWN: 2,
        Z_DEFLATED: 8
    };
    const {_tr_init: Br, _tr_stored_block: Ut, _tr_flush_block: Hr, _tr_tally: re, _tr_align: Zr} = Lr, {
            Z_NO_FLUSH: ae,
            Z_PARTIAL_FLUSH: Vr,
            Z_FULL_FLUSH: Gr,
            Z_FINISH: $,
            Z_BLOCK: Zn,
            Z_OK: F,
            Z_STREAM_END: Vn,
            Z_STREAM_ERROR: K,
            Z_DATA_ERROR: $r,
            Z_BUF_ERROR: zt,
            Z_DEFAULT_COMPRESSION: Xr,
            Z_FILTERED: Wr,
            Z_HUFFMAN_ONLY: at,
            Z_RLE: jr,
            Z_FIXED: Kr,
            Z_DEFAULT_STRATEGY: Yr,
            Z_UNKNOWN: qr,
            Z_DEFLATED: ot
        } = He, Jr = 9, Qr = 15, ea = 8, Bt = 256 + 1 + 29, ta = 30, na = 19, ia = 2 * Bt + 1, ra = 15, T = 3, oe = 258,
        Y = oe + T + 1, aa = 32, Se = 42, Ht = 57, Zt = 69, Vt = 73, Gt = 91, $t = 103, de = 113, Ze = 666, U = 1,
        Ae = 2, he = 3, Te = 4, oa = 3, _e = (e, n) => (e.msg = Ee[n], n), Gn = e => e * 2 - (e > 4 ? 9 : 0),
        se = e => {
            let n = e.length;
            for (; --n >= 0;) e[n] = 0
        }, sa = e => {
            let n, t, i, r = e.w_size;
            n = e.hash_size, i = n;
            do t = e.head[--i], e.head[i] = t >= r ? t - r : 0; while (--n);
            n = r, i = n;
            do t = e.prev[--i], e.prev[i] = t >= r ? t - r : 0; while (--n)
        };
    let le = (e, n, t) => (n << e.hash_shift ^ t) & e.hash_mask;
    const Z = e => {
        const n = e.state;
        let t = n.pending;
        t > e.avail_out && (t = e.avail_out), t !== 0 && (e.output.set(n.pending_buf.subarray(n.pending_out, n.pending_out + t), e.next_out), e.next_out += t, n.pending_out += t, e.total_out += t, e.avail_out -= t, n.pending -= t, n.pending === 0 && (n.pending_out = 0))
    }, V = (e, n) => {
        Hr(e, e.block_start >= 0 ? e.block_start : -1, e.strstart - e.block_start, n), e.block_start = e.strstart, Z(e.strm)
    }, R = (e, n) => {
        e.pending_buf[e.pending++] = n
    }, Ve = (e, n) => {
        e.pending_buf[e.pending++] = n >>> 8 & 255, e.pending_buf[e.pending++] = n & 255
    }, Xt = (e, n, t, i) => {
        let r = e.avail_in;
        return r > i && (r = i), r === 0 ? 0 : (e.avail_in -= r, n.set(e.input.subarray(e.next_in, e.next_in + r), t), e.state.wrap === 1 ? e.adler = Be(e.adler, n, r, t) : e.state.wrap === 2 && (e.adler = N(e.adler, n, r, t)), e.next_in += r, e.total_in += r, r)
    }, $n = (e, n) => {
        let t = e.max_chain_length, i = e.strstart, r, a, o = e.prev_length, s = e.nice_match;
        const f = e.strstart > e.w_size - Y ? e.strstart - (e.w_size - Y) : 0, l = e.window, c = e.w_mask, _ = e.prev,
            h = e.strstart + oe;
        let u = l[i + o - 1], d = l[i + o];
        e.prev_length >= e.good_match && (t >>= 2), s > e.lookahead && (s = e.lookahead);
        do if (r = n, !(l[r + o] !== d || l[r + o - 1] !== u || l[r] !== l[i] || l[++r] !== l[i + 1])) {
            i += 2, r++;
            do ; while (l[++i] === l[++r] && l[++i] === l[++r] && l[++i] === l[++r] && l[++i] === l[++r] && l[++i] === l[++r] && l[++i] === l[++r] && l[++i] === l[++r] && l[++i] === l[++r] && i < h);
            if (a = oe - (h - i), i = h - oe, a > o) {
                if (e.match_start = n, o = a, a >= s) break;
                u = l[i + o - 1], d = l[i + o]
            }
        } while ((n = _[n & c]) > f && --t !== 0);
        return o <= e.lookahead ? o : e.lookahead
    }, ke = e => {
        const n = e.w_size;
        let t, i, r;
        do {
            if (i = e.window_size - e.lookahead - e.strstart, e.strstart >= n + (n - Y) && (e.window.set(e.window.subarray(n, n + n - i), 0), e.match_start -= n, e.strstart -= n, e.block_start -= n, e.insert > e.strstart && (e.insert = e.strstart), sa(e), i += n), e.strm.avail_in === 0) break;
            if (t = Xt(e.strm, e.window, e.strstart + e.lookahead, i), e.lookahead += t, e.lookahead + e.insert >= T) for (r = e.strstart - e.insert, e.ins_h = e.window[r], e.ins_h = le(e, e.ins_h, e.window[r + 1]); e.insert && (e.ins_h = le(e, e.ins_h, e.window[r + T - 1]), e.prev[r & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = r, r++, e.insert--, !(e.lookahead + e.insert < T));) ;
        } while (e.lookahead < Y && e.strm.avail_in !== 0)
    }, Xn = (e, n) => {
        let t = e.pending_buf_size - 5 > e.w_size ? e.w_size : e.pending_buf_size - 5, i, r, a, o = 0,
            s = e.strm.avail_in;
        do {
            if (i = 65535, a = e.bi_valid + 42 >> 3, e.strm.avail_out < a || (a = e.strm.avail_out - a, r = e.strstart - e.block_start, i > r + e.strm.avail_in && (i = r + e.strm.avail_in), i > a && (i = a), i < t && (i === 0 && n !== $ || n === ae || i !== r + e.strm.avail_in))) break;
            o = n === $ && i === r + e.strm.avail_in ? 1 : 0, Ut(e, 0, 0, o), e.pending_buf[e.pending - 4] = i, e.pending_buf[e.pending - 3] = i >> 8, e.pending_buf[e.pending - 2] = ~i, e.pending_buf[e.pending - 1] = ~i >> 8, Z(e.strm), r && (r > i && (r = i), e.strm.output.set(e.window.subarray(e.block_start, e.block_start + r), e.strm.next_out), e.strm.next_out += r, e.strm.avail_out -= r, e.strm.total_out += r, e.block_start += r, i -= r), i && (Xt(e.strm, e.strm.output, e.strm.next_out, i), e.strm.next_out += i, e.strm.avail_out -= i, e.strm.total_out += i)
        } while (o === 0);
        return s -= e.strm.avail_in, s && (s >= e.w_size ? (e.matches = 2, e.window.set(e.strm.input.subarray(e.strm.next_in - e.w_size, e.strm.next_in), 0), e.strstart = e.w_size, e.insert = e.strstart) : (e.window_size - e.strstart <= s && (e.strstart -= e.w_size, e.window.set(e.window.subarray(e.w_size, e.w_size + e.strstart), 0), e.matches < 2 && e.matches++, e.insert > e.strstart && (e.insert = e.strstart)), e.window.set(e.strm.input.subarray(e.strm.next_in - s, e.strm.next_in), e.strstart), e.strstart += s, e.insert += s > e.w_size - e.insert ? e.w_size - e.insert : s), e.block_start = e.strstart), e.high_water < e.strstart && (e.high_water = e.strstart), o ? Te : n !== ae && n !== $ && e.strm.avail_in === 0 && e.strstart === e.block_start ? Ae : (a = e.window_size - e.strstart, e.strm.avail_in > a && e.block_start >= e.w_size && (e.block_start -= e.w_size, e.strstart -= e.w_size, e.window.set(e.window.subarray(e.w_size, e.w_size + e.strstart), 0), e.matches < 2 && e.matches++, a += e.w_size, e.insert > e.strstart && (e.insert = e.strstart)), a > e.strm.avail_in && (a = e.strm.avail_in), a && (Xt(e.strm, e.window, e.strstart, a), e.strstart += a, e.insert += a > e.w_size - e.insert ? e.w_size - e.insert : a), e.high_water < e.strstart && (e.high_water = e.strstart), a = e.bi_valid + 42 >> 3, a = e.pending_buf_size - a > 65535 ? 65535 : e.pending_buf_size - a, t = a > e.w_size ? e.w_size : a, r = e.strstart - e.block_start, (r >= t || (r || n === $) && n !== ae && e.strm.avail_in === 0 && r <= a) && (i = r > a ? a : r, o = n === $ && e.strm.avail_in === 0 && i === r ? 1 : 0, Ut(e, e.block_start, i, o), e.block_start += i, Z(e.strm)), o ? he : U)
    }, Wt = (e, n) => {
        let t, i;
        for (; ;) {
            if (e.lookahead < Y) {
                if (ke(e), e.lookahead < Y && n === ae) return U;
                if (e.lookahead === 0) break
            }
            if (t = 0, e.lookahead >= T && (e.ins_h = le(e, e.ins_h, e.window[e.strstart + T - 1]), t = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart), t !== 0 && e.strstart - t <= e.w_size - Y && (e.match_length = $n(e, t)), e.match_length >= T) if (i = re(e, e.strstart - e.match_start, e.match_length - T), e.lookahead -= e.match_length, e.match_length <= e.max_lazy_match && e.lookahead >= T) {
                e.match_length--;
                do e.strstart++, e.ins_h = le(e, e.ins_h, e.window[e.strstart + T - 1]), t = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart; while (--e.match_length !== 0);
                e.strstart++
            } else e.strstart += e.match_length, e.match_length = 0, e.ins_h = e.window[e.strstart], e.ins_h = le(e, e.ins_h, e.window[e.strstart + 1]); else i = re(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++;
            if (i && (V(e, !1), e.strm.avail_out === 0)) return U
        }
        return e.insert = e.strstart < T - 1 ? e.strstart : T - 1, n === $ ? (V(e, !0), e.strm.avail_out === 0 ? he : Te) : e.sym_next && (V(e, !1), e.strm.avail_out === 0) ? U : Ae
    }, Re = (e, n) => {
        let t, i, r;
        for (; ;) {
            if (e.lookahead < Y) {
                if (ke(e), e.lookahead < Y && n === ae) return U;
                if (e.lookahead === 0) break
            }
            if (t = 0, e.lookahead >= T && (e.ins_h = le(e, e.ins_h, e.window[e.strstart + T - 1]), t = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart), e.prev_length = e.match_length, e.prev_match = e.match_start, e.match_length = T - 1, t !== 0 && e.prev_length < e.max_lazy_match && e.strstart - t <= e.w_size - Y && (e.match_length = $n(e, t), e.match_length <= 5 && (e.strategy === Wr || e.match_length === T && e.strstart - e.match_start > 4096) && (e.match_length = T - 1)), e.prev_length >= T && e.match_length <= e.prev_length) {
                r = e.strstart + e.lookahead - T, i = re(e, e.strstart - 1 - e.prev_match, e.prev_length - T), e.lookahead -= e.prev_length - 1, e.prev_length -= 2;
                do ++e.strstart <= r && (e.ins_h = le(e, e.ins_h, e.window[e.strstart + T - 1]), t = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart); while (--e.prev_length !== 0);
                if (e.match_available = 0, e.match_length = T - 1, e.strstart++, i && (V(e, !1), e.strm.avail_out === 0)) return U
            } else if (e.match_available) {
                if (i = re(e, 0, e.window[e.strstart - 1]), i && V(e, !1), e.strstart++, e.lookahead--, e.strm.avail_out === 0) return U
            } else e.match_available = 1, e.strstart++, e.lookahead--
        }
        return e.match_available && (i = re(e, 0, e.window[e.strstart - 1]), e.match_available = 0), e.insert = e.strstart < T - 1 ? e.strstart : T - 1, n === $ ? (V(e, !0), e.strm.avail_out === 0 ? he : Te) : e.sym_next && (V(e, !1), e.strm.avail_out === 0) ? U : Ae
    }, la = (e, n) => {
        let t, i, r, a;
        const o = e.window;
        for (; ;) {
            if (e.lookahead <= oe) {
                if (ke(e), e.lookahead <= oe && n === ae) return U;
                if (e.lookahead === 0) break
            }
            if (e.match_length = 0, e.lookahead >= T && e.strstart > 0 && (r = e.strstart - 1, i = o[r], i === o[++r] && i === o[++r] && i === o[++r])) {
                a = e.strstart + oe;
                do ; while (i === o[++r] && i === o[++r] && i === o[++r] && i === o[++r] && i === o[++r] && i === o[++r] && i === o[++r] && i === o[++r] && r < a);
                e.match_length = oe - (a - r), e.match_length > e.lookahead && (e.match_length = e.lookahead)
            }
            if (e.match_length >= T ? (t = re(e, 1, e.match_length - T), e.lookahead -= e.match_length, e.strstart += e.match_length, e.match_length = 0) : (t = re(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++), t && (V(e, !1), e.strm.avail_out === 0)) return U
        }
        return e.insert = 0, n === $ ? (V(e, !0), e.strm.avail_out === 0 ? he : Te) : e.sym_next && (V(e, !1), e.strm.avail_out === 0) ? U : Ae
    }, ca = (e, n) => {
        let t;
        for (; ;) {
            if (e.lookahead === 0 && (ke(e), e.lookahead === 0)) {
                if (n === ae) return U;
                break
            }
            if (e.match_length = 0, t = re(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++, t && (V(e, !1), e.strm.avail_out === 0)) return U
        }
        return e.insert = 0, n === $ ? (V(e, !0), e.strm.avail_out === 0 ? he : Te) : e.sym_next && (V(e, !1), e.strm.avail_out === 0) ? U : Ae
    };

    function q(e, n, t, i, r) {
        this.good_length = e, this.max_lazy = n, this.nice_length = t, this.max_chain = i, this.func = r
    }

    const Ge = [new q(0, 0, 0, 0, Xn), new q(4, 4, 8, 4, Wt), new q(4, 5, 16, 8, Wt), new q(4, 6, 32, 32, Wt), new q(4, 4, 16, 16, Re), new q(8, 16, 32, 32, Re), new q(8, 16, 128, 128, Re), new q(8, 32, 128, 256, Re), new q(32, 128, 258, 1024, Re), new q(32, 258, 258, 4096, Re)],
        fa = e => {
            e.window_size = 2 * e.w_size, se(e.head), e.max_lazy_match = Ge[e.level].max_lazy, e.good_match = Ge[e.level].good_length, e.nice_match = Ge[e.level].nice_length, e.max_chain_length = Ge[e.level].max_chain, e.strstart = 0, e.block_start = 0, e.lookahead = 0, e.insert = 0, e.match_length = e.prev_length = T - 1, e.match_available = 0, e.ins_h = 0
        };

    function ua() {
        this.strm = null, this.status = 0, this.pending_buf = null, this.pending_buf_size = 0, this.pending_out = 0, this.pending = 0, this.wrap = 0, this.gzhead = null, this.gzindex = 0, this.method = ot, this.last_flush = -1, this.w_size = 0, this.w_bits = 0, this.w_mask = 0, this.window = null, this.window_size = 0, this.prev = null, this.head = null, this.ins_h = 0, this.hash_size = 0, this.hash_bits = 0, this.hash_mask = 0, this.hash_shift = 0, this.block_start = 0, this.match_length = 0, this.prev_match = 0, this.match_available = 0, this.strstart = 0, this.match_start = 0, this.lookahead = 0, this.prev_length = 0, this.max_chain_length = 0, this.max_lazy_match = 0, this.level = 0, this.strategy = 0, this.good_match = 0, this.nice_match = 0, this.dyn_ltree = new Uint16Array(ia * 2), this.dyn_dtree = new Uint16Array((2 * ta + 1) * 2), this.bl_tree = new Uint16Array((2 * na + 1) * 2), se(this.dyn_ltree), se(this.dyn_dtree), se(this.bl_tree), this.l_desc = null, this.d_desc = null, this.bl_desc = null, this.bl_count = new Uint16Array(ra + 1), this.heap = new Uint16Array(2 * Bt + 1), se(this.heap), this.heap_len = 0, this.heap_max = 0, this.depth = new Uint16Array(2 * Bt + 1), se(this.depth), this.sym_buf = 0, this.lit_bufsize = 0, this.sym_next = 0, this.sym_end = 0, this.opt_len = 0, this.static_len = 0, this.matches = 0, this.insert = 0, this.bi_buf = 0, this.bi_valid = 0
    }

    const $e = e => {
        if (!e) return 1;
        const n = e.state;
        return !n || n.strm !== e || n.status !== Se && n.status !== Ht && n.status !== Zt && n.status !== Vt && n.status !== Gt && n.status !== $t && n.status !== de && n.status !== Ze ? 1 : 0
    }, Wn = e => {
        if ($e(e)) return _e(e, K);
        e.total_in = e.total_out = 0, e.data_type = qr;
        const n = e.state;
        return n.pending = 0, n.pending_out = 0, n.wrap < 0 && (n.wrap = -n.wrap), n.status = n.wrap === 2 ? Ht : n.wrap ? Se : de, e.adler = n.wrap === 2 ? 0 : 1, n.last_flush = -2, Br(n), F
    }, jn = e => {
        const n = Wn(e);
        return n === F && fa(e.state), n
    }, da = (e, n) => $e(e) || e.state.wrap !== 2 ? K : (e.state.gzhead = n, F), Kn = (e, n, t, i, r, a) => {
        if (!e) return K;
        let o = 1;
        if (n === Xr && (n = 6), i < 0 ? (o = 0, i = -i) : i > 15 && (o = 2, i -= 16), r < 1 || r > Jr || t !== ot || i < 8 || i > 15 || n < 0 || n > 9 || a < 0 || a > Kr || i === 8 && o !== 1) return _e(e, K);
        i === 8 && (i = 9);
        const s = new ua;
        return e.state = s, s.strm = e, s.status = Se, s.wrap = o, s.gzhead = null, s.w_bits = i, s.w_size = 1 << s.w_bits, s.w_mask = s.w_size - 1, s.hash_bits = r + 7, s.hash_size = 1 << s.hash_bits, s.hash_mask = s.hash_size - 1, s.hash_shift = ~~((s.hash_bits + T - 1) / T), s.window = new Uint8Array(s.w_size * 2), s.head = new Uint16Array(s.hash_size), s.prev = new Uint16Array(s.w_size), s.lit_bufsize = 1 << r + 6, s.pending_buf_size = s.lit_bufsize * 4, s.pending_buf = new Uint8Array(s.pending_buf_size), s.sym_buf = s.lit_bufsize, s.sym_end = (s.lit_bufsize - 1) * 3, s.level = n, s.strategy = a, s.method = t, jn(e)
    }, ha = (e, n) => Kn(e, n, ot, Qr, ea, Yr), _a = (e, n) => {
        if ($e(e) || n > Zn || n < 0) return e ? _e(e, K) : K;
        const t = e.state;
        if (!e.output || e.avail_in !== 0 && !e.input || t.status === Ze && n !== $) return _e(e, e.avail_out === 0 ? zt : K);
        const i = t.last_flush;
        if (t.last_flush = n, t.pending !== 0) {
            if (Z(e), e.avail_out === 0) return t.last_flush = -1, F
        } else if (e.avail_in === 0 && Gn(n) <= Gn(i) && n !== $) return _e(e, zt);
        if (t.status === Ze && e.avail_in !== 0) return _e(e, zt);
        if (t.status === Se && t.wrap === 0 && (t.status = de), t.status === Se) {
            let r = ot + (t.w_bits - 8 << 4) << 8, a = -1;
            if (t.strategy >= at || t.level < 2 ? a = 0 : t.level < 6 ? a = 1 : t.level === 6 ? a = 2 : a = 3, r |= a << 6, t.strstart !== 0 && (r |= aa), r += 31 - r % 31, Ve(t, r), t.strstart !== 0 && (Ve(t, e.adler >>> 16), Ve(t, e.adler & 65535)), e.adler = 1, t.status = de, Z(e), t.pending !== 0) return t.last_flush = -1, F
        }
        if (t.status === Ht) {
            if (e.adler = 0, R(t, 31), R(t, 139), R(t, 8), t.gzhead) R(t, (t.gzhead.text ? 1 : 0) + (t.gzhead.hcrc ? 2 : 0) + (t.gzhead.extra ? 4 : 0) + (t.gzhead.name ? 8 : 0) + (t.gzhead.comment ? 16 : 0)), R(t, t.gzhead.time & 255), R(t, t.gzhead.time >> 8 & 255), R(t, t.gzhead.time >> 16 & 255), R(t, t.gzhead.time >> 24 & 255), R(t, t.level === 9 ? 2 : t.strategy >= at || t.level < 2 ? 4 : 0), R(t, t.gzhead.os & 255), t.gzhead.extra && t.gzhead.extra.length && (R(t, t.gzhead.extra.length & 255), R(t, t.gzhead.extra.length >> 8 & 255)), t.gzhead.hcrc && (e.adler = N(e.adler, t.pending_buf, t.pending, 0)), t.gzindex = 0, t.status = Zt; else if (R(t, 0), R(t, 0), R(t, 0), R(t, 0), R(t, 0), R(t, t.level === 9 ? 2 : t.strategy >= at || t.level < 2 ? 4 : 0), R(t, oa), t.status = de, Z(e), t.pending !== 0) return t.last_flush = -1, F
        }
        if (t.status === Zt) {
            if (t.gzhead.extra) {
                let r = t.pending, a = (t.gzhead.extra.length & 65535) - t.gzindex;
                for (; t.pending + a > t.pending_buf_size;) {
                    let s = t.pending_buf_size - t.pending;
                    if (t.pending_buf.set(t.gzhead.extra.subarray(t.gzindex, t.gzindex + s), t.pending), t.pending = t.pending_buf_size, t.gzhead.hcrc && t.pending > r && (e.adler = N(e.adler, t.pending_buf, t.pending - r, r)), t.gzindex += s, Z(e), t.pending !== 0) return t.last_flush = -1, F;
                    r = 0, a -= s
                }
                let o = new Uint8Array(t.gzhead.extra);
                t.pending_buf.set(o.subarray(t.gzindex, t.gzindex + a), t.pending), t.pending += a, t.gzhead.hcrc && t.pending > r && (e.adler = N(e.adler, t.pending_buf, t.pending - r, r)), t.gzindex = 0
            }
            t.status = Vt
        }
        if (t.status === Vt) {
            if (t.gzhead.name) {
                let r = t.pending, a;
                do {
                    if (t.pending === t.pending_buf_size) {
                        if (t.gzhead.hcrc && t.pending > r && (e.adler = N(e.adler, t.pending_buf, t.pending - r, r)), Z(e), t.pending !== 0) return t.last_flush = -1, F;
                        r = 0
                    }
                    t.gzindex < t.gzhead.name.length ? a = t.gzhead.name.charCodeAt(t.gzindex++) & 255 : a = 0, R(t, a)
                } while (a !== 0);
                t.gzhead.hcrc && t.pending > r && (e.adler = N(e.adler, t.pending_buf, t.pending - r, r)), t.gzindex = 0
            }
            t.status = Gt
        }
        if (t.status === Gt) {
            if (t.gzhead.comment) {
                let r = t.pending, a;
                do {
                    if (t.pending === t.pending_buf_size) {
                        if (t.gzhead.hcrc && t.pending > r && (e.adler = N(e.adler, t.pending_buf, t.pending - r, r)), Z(e), t.pending !== 0) return t.last_flush = -1, F;
                        r = 0
                    }
                    t.gzindex < t.gzhead.comment.length ? a = t.gzhead.comment.charCodeAt(t.gzindex++) & 255 : a = 0, R(t, a)
                } while (a !== 0);
                t.gzhead.hcrc && t.pending > r && (e.adler = N(e.adler, t.pending_buf, t.pending - r, r))
            }
            t.status = $t
        }
        if (t.status === $t) {
            if (t.gzhead.hcrc) {
                if (t.pending + 2 > t.pending_buf_size && (Z(e), t.pending !== 0)) return t.last_flush = -1, F;
                R(t, e.adler & 255), R(t, e.adler >> 8 & 255), e.adler = 0
            }
            if (t.status = de, Z(e), t.pending !== 0) return t.last_flush = -1, F
        }
        if (e.avail_in !== 0 || t.lookahead !== 0 || n !== ae && t.status !== Ze) {
            let r = t.level === 0 ? Xn(t, n) : t.strategy === at ? ca(t, n) : t.strategy === jr ? la(t, n) : Ge[t.level].func(t, n);
            if ((r === he || r === Te) && (t.status = Ze), r === U || r === he) return e.avail_out === 0 && (t.last_flush = -1), F;
            if (r === Ae && (n === Vr ? Zr(t) : n !== Zn && (Ut(t, 0, 0, !1), n === Gr && (se(t.head), t.lookahead === 0 && (t.strstart = 0, t.block_start = 0, t.insert = 0))), Z(e), e.avail_out === 0)) return t.last_flush = -1, F
        }
        return n !== $ ? F : t.wrap <= 0 ? Vn : (t.wrap === 2 ? (R(t, e.adler & 255), R(t, e.adler >> 8 & 255), R(t, e.adler >> 16 & 255), R(t, e.adler >> 24 & 255), R(t, e.total_in & 255), R(t, e.total_in >> 8 & 255), R(t, e.total_in >> 16 & 255), R(t, e.total_in >> 24 & 255)) : (Ve(t, e.adler >>> 16), Ve(t, e.adler & 65535)), Z(e), t.wrap > 0 && (t.wrap = -t.wrap), t.pending !== 0 ? F : Vn)
    }, ma = e => {
        if ($e(e)) return K;
        const n = e.state.status;
        return e.state = null, n === de ? _e(e, $r) : F
    }, ga = (e, n) => {
        let t = n.length;
        if ($e(e)) return K;
        const i = e.state, r = i.wrap;
        if (r === 2 || r === 1 && i.status !== Se || i.lookahead) return K;
        if (r === 1 && (e.adler = Be(e.adler, n, t, 0)), i.wrap = 0, t >= i.w_size) {
            r === 0 && (se(i.head), i.strstart = 0, i.block_start = 0, i.insert = 0);
            let f = new Uint8Array(i.w_size);
            f.set(n.subarray(t - i.w_size, t), 0), n = f, t = i.w_size
        }
        const a = e.avail_in, o = e.next_in, s = e.input;
        for (e.avail_in = t, e.next_in = 0, e.input = n, ke(i); i.lookahead >= T;) {
            let f = i.strstart, l = i.lookahead - (T - 1);
            do i.ins_h = le(i, i.ins_h, i.window[f + T - 1]), i.prev[f & i.w_mask] = i.head[i.ins_h], i.head[i.ins_h] = f, f++; while (--l);
            i.strstart = f, i.lookahead = T - 1, ke(i)
        }
        return i.strstart += i.lookahead, i.block_start = i.strstart, i.insert = i.lookahead, i.lookahead = 0, i.match_length = i.prev_length = T - 1, i.match_available = 0, e.next_in = o, e.input = s, e.avail_in = a, i.wrap = r, F
    };
    var pa = ha, wa = Kn, ba = jn, ya = Wn, xa = da, va = _a, Ea = ma, Sa = ga,
        Aa = "pako deflate (from Nodeca project)", Xe = {
            deflateInit: pa,
            deflateInit2: wa,
            deflateReset: ba,
            deflateResetKeep: ya,
            deflateSetHeader: xa,
            deflate: va,
            deflateEnd: Ea,
            deflateSetDictionary: Sa,
            deflateInfo: Aa
        };
    const Ta = (e, n) => Object.prototype.hasOwnProperty.call(e, n);
    var ka = function (e) {
        const n = Array.prototype.slice.call(arguments, 1);
        for (; n.length;) {
            const t = n.shift();
            if (t) {
                if (typeof t != "object") throw new TypeError(t + "must be non-object");
                for (const i in t) Ta(t, i) && (e[i] = t[i])
            }
        }
        return e
    }, Ra = e => {
        let n = 0;
        for (let i = 0, r = e.length; i < r; i++) n += e[i].length;
        const t = new Uint8Array(n);
        for (let i = 0, r = 0, a = e.length; i < a; i++) {
            let o = e[i];
            t.set(o, r), r += o.length
        }
        return t
    }, st = {assign: ka, flattenChunks: Ra};
    let Yn = !0;
    try {
        String.fromCharCode.apply(null, new Uint8Array(1))
    } catch {
        Yn = !1
    }
    const We = new Uint8Array(256);
    for (let e = 0; e < 256; e++) We[e] = e >= 252 ? 6 : e >= 248 ? 5 : e >= 240 ? 4 : e >= 224 ? 3 : e >= 192 ? 2 : 1;
    We[254] = We[254] = 1;
    var Ia = e => {
        if (typeof TextEncoder == "function" && TextEncoder.prototype.encode) return new TextEncoder().encode(e);
        let n, t, i, r, a, o = e.length, s = 0;
        for (r = 0; r < o; r++) t = e.charCodeAt(r), (t & 64512) === 55296 && r + 1 < o && (i = e.charCodeAt(r + 1), (i & 64512) === 56320 && (t = 65536 + (t - 55296 << 10) + (i - 56320), r++)), s += t < 128 ? 1 : t < 2048 ? 2 : t < 65536 ? 3 : 4;
        for (n = new Uint8Array(s), a = 0, r = 0; a < s; r++) t = e.charCodeAt(r), (t & 64512) === 55296 && r + 1 < o && (i = e.charCodeAt(r + 1), (i & 64512) === 56320 && (t = 65536 + (t - 55296 << 10) + (i - 56320), r++)), t < 128 ? n[a++] = t : t < 2048 ? (n[a++] = 192 | t >>> 6, n[a++] = 128 | t & 63) : t < 65536 ? (n[a++] = 224 | t >>> 12, n[a++] = 128 | t >>> 6 & 63, n[a++] = 128 | t & 63) : (n[a++] = 240 | t >>> 18, n[a++] = 128 | t >>> 12 & 63, n[a++] = 128 | t >>> 6 & 63, n[a++] = 128 | t & 63);
        return n
    };
    const Ma = (e, n) => {
        if (n < 65534 && e.subarray && Yn) return String.fromCharCode.apply(null, e.length === n ? e : e.subarray(0, n));
        let t = "";
        for (let i = 0; i < n; i++) t += String.fromCharCode(e[i]);
        return t
    };
    var Oa = (e, n) => {
        const t = n || e.length;
        if (typeof TextDecoder == "function" && TextDecoder.prototype.decode) return new TextDecoder().decode(e.subarray(0, n));
        let i, r;
        const a = new Array(t * 2);
        for (r = 0, i = 0; i < t;) {
            let o = e[i++];
            if (o < 128) {
                a[r++] = o;
                continue
            }
            let s = We[o];
            if (s > 4) {
                a[r++] = 65533, i += s - 1;
                continue
            }
            for (o &= s === 2 ? 31 : s === 3 ? 15 : 7; s > 1 && i < t;) o = o << 6 | e[i++] & 63, s--;
            if (s > 1) {
                a[r++] = 65533;
                continue
            }
            o < 65536 ? a[r++] = o : (o -= 65536, a[r++] = 55296 | o >> 10 & 1023, a[r++] = 56320 | o & 1023)
        }
        return Ma(a, r)
    }, Da = (e, n) => {
        n = n || e.length, n > e.length && (n = e.length);
        let t = n - 1;
        for (; t >= 0 && (e[t] & 192) === 128;) t--;
        return t < 0 || t === 0 ? n : t + We[e[t]] > n ? t : n
    }, je = {string2buf: Ia, buf2string: Oa, utf8border: Da};

    function Ca() {
        this.input = null, this.next_in = 0, this.avail_in = 0, this.total_in = 0, this.output = null, this.next_out = 0, this.avail_out = 0, this.total_out = 0, this.msg = "", this.state = null, this.data_type = 2, this.adler = 0
    }

    var qn = Ca;
    const Jn = Object.prototype.toString, {
        Z_NO_FLUSH: Na,
        Z_SYNC_FLUSH: Fa,
        Z_FULL_FLUSH: Pa,
        Z_FINISH: La,
        Z_OK: lt,
        Z_STREAM_END: Ua,
        Z_DEFAULT_COMPRESSION: za,
        Z_DEFAULT_STRATEGY: Ba,
        Z_DEFLATED: Ha
    } = He;

    function Ke(e) {
        this.options = st.assign({
            level: za,
            method: Ha,
            chunkSize: 16384,
            windowBits: 15,
            memLevel: 8,
            strategy: Ba
        }, e || {});
        let n = this.options;
        n.raw && n.windowBits > 0 ? n.windowBits = -n.windowBits : n.gzip && n.windowBits > 0 && n.windowBits < 16 && (n.windowBits += 16), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new qn, this.strm.avail_out = 0;
        let t = Xe.deflateInit2(this.strm, n.level, n.method, n.windowBits, n.memLevel, n.strategy);
        if (t !== lt) throw new Error(Ee[t]);
        if (n.header && Xe.deflateSetHeader(this.strm, n.header), n.dictionary) {
            let i;
            if (typeof n.dictionary == "string" ? i = je.string2buf(n.dictionary) : Jn.call(n.dictionary) === "[object ArrayBuffer]" ? i = new Uint8Array(n.dictionary) : i = n.dictionary, t = Xe.deflateSetDictionary(this.strm, i), t !== lt) throw new Error(Ee[t]);
            this._dict_set = !0
        }
    }

    Ke.prototype.push = function (e, n) {
        const t = this.strm, i = this.options.chunkSize;
        let r, a;
        if (this.ended) return !1;
        for (n === ~~n ? a = n : a = n === !0 ? La : Na, typeof e == "string" ? t.input = je.string2buf(e) : Jn.call(e) === "[object ArrayBuffer]" ? t.input = new Uint8Array(e) : t.input = e, t.next_in = 0, t.avail_in = t.input.length; ;) {
            if (t.avail_out === 0 && (t.output = new Uint8Array(i), t.next_out = 0, t.avail_out = i), (a === Fa || a === Pa) && t.avail_out <= 6) {
                this.onData(t.output.subarray(0, t.next_out)), t.avail_out = 0;
                continue
            }
            if (r = Xe.deflate(t, a), r === Ua) return t.next_out > 0 && this.onData(t.output.subarray(0, t.next_out)), r = Xe.deflateEnd(this.strm), this.onEnd(r), this.ended = !0, r === lt;
            if (t.avail_out === 0) {
                this.onData(t.output);
                continue
            }
            if (a > 0 && t.next_out > 0) {
                this.onData(t.output.subarray(0, t.next_out)), t.avail_out = 0;
                continue
            }
            if (t.avail_in === 0) break
        }
        return !0
    }, Ke.prototype.onData = function (e) {
        this.chunks.push(e)
    }, Ke.prototype.onEnd = function (e) {
        e === lt && (this.result = st.flattenChunks(this.chunks)), this.chunks = [], this.err = e, this.msg = this.strm.msg
    };

    function jt(e, n) {
        const t = new Ke(n);
        if (t.push(e, !0), t.err) throw t.msg || Ee[t.err];
        return t.result
    }

    function Za(e, n) {
        return n = n || {}, n.raw = !0, jt(e, n)
    }

    function Va(e, n) {
        return n = n || {}, n.gzip = !0, jt(e, n)
    }

    var Ga = Ke, $a = jt, Xa = Za, Wa = Va, ja = He,
        Ka = {Deflate: Ga, deflate: $a, deflateRaw: Xa, gzip: Wa, constants: ja};
    const ct = 16209, Ya = 16191;
    var qa = function (n, t) {
        let i, r, a, o, s, f, l, c, _, h, u, d, p, g, b, v, x, m, k, C, y, I, w, E;
        const A = n.state;
        i = n.next_in, w = n.input, r = i + (n.avail_in - 5), a = n.next_out, E = n.output, o = a - (t - n.avail_out), s = a + (n.avail_out - 257), f = A.dmax, l = A.wsize, c = A.whave, _ = A.wnext, h = A.window, u = A.hold, d = A.bits, p = A.lencode, g = A.distcode, b = (1 << A.lenbits) - 1, v = (1 << A.distbits) - 1;
        e:do {
            d < 15 && (u += w[i++] << d, d += 8, u += w[i++] << d, d += 8), x = p[u & b];
            t:for (; ;) {
                if (m = x >>> 24, u >>>= m, d -= m, m = x >>> 16 & 255, m === 0) E[a++] = x & 65535; else if (m & 16) {
                    k = x & 65535, m &= 15, m && (d < m && (u += w[i++] << d, d += 8), k += u & (1 << m) - 1, u >>>= m, d -= m), d < 15 && (u += w[i++] << d, d += 8, u += w[i++] << d, d += 8), x = g[u & v];
                    n:for (; ;) {
                        if (m = x >>> 24, u >>>= m, d -= m, m = x >>> 16 & 255, m & 16) {
                            if (C = x & 65535, m &= 15, d < m && (u += w[i++] << d, d += 8, d < m && (u += w[i++] << d, d += 8)), C += u & (1 << m) - 1, C > f) {
                                n.msg = "invalid distance too far back", A.mode = ct;
                                break e
                            }
                            if (u >>>= m, d -= m, m = a - o, C > m) {
                                if (m = C - m, m > c && A.sane) {
                                    n.msg = "invalid distance too far back", A.mode = ct;
                                    break e
                                }
                                if (y = 0, I = h, _ === 0) {
                                    if (y += l - m, m < k) {
                                        k -= m;
                                        do E[a++] = h[y++]; while (--m);
                                        y = a - C, I = E
                                    }
                                } else if (_ < m) {
                                    if (y += l + _ - m, m -= _, m < k) {
                                        k -= m;
                                        do E[a++] = h[y++]; while (--m);
                                        if (y = 0, _ < k) {
                                            m = _, k -= m;
                                            do E[a++] = h[y++]; while (--m);
                                            y = a - C, I = E
                                        }
                                    }
                                } else if (y += _ - m, m < k) {
                                    k -= m;
                                    do E[a++] = h[y++]; while (--m);
                                    y = a - C, I = E
                                }
                                for (; k > 2;) E[a++] = I[y++], E[a++] = I[y++], E[a++] = I[y++], k -= 3;
                                k && (E[a++] = I[y++], k > 1 && (E[a++] = I[y++]))
                            } else {
                                y = a - C;
                                do E[a++] = E[y++], E[a++] = E[y++], E[a++] = E[y++], k -= 3; while (k > 2);
                                k && (E[a++] = E[y++], k > 1 && (E[a++] = E[y++]))
                            }
                        } else if (m & 64) {
                            n.msg = "invalid distance code", A.mode = ct;
                            break e
                        } else {
                            x = g[(x & 65535) + (u & (1 << m) - 1)];
                            continue n
                        }
                        break
                    }
                } else if (m & 64) if (m & 32) {
                    A.mode = Ya;
                    break e
                } else {
                    n.msg = "invalid literal/length code", A.mode = ct;
                    break e
                } else {
                    x = p[(x & 65535) + (u & (1 << m) - 1)];
                    continue t
                }
                break
            }
        } while (i < r && a < s);
        k = d >> 3, i -= k, d -= k << 3, u &= (1 << d) - 1, n.next_in = i, n.next_out = a, n.avail_in = i < r ? 5 + (r - i) : 5 - (i - r), n.avail_out = a < s ? 257 + (s - a) : 257 - (a - s), A.hold = u, A.bits = d
    };
    const Ie = 15, Qn = 852, ei = 592, ti = 0, Kt = 1, ni = 2,
        Ja = new Uint16Array([3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0]),
        Qa = new Uint8Array([16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78]),
        eo = new Uint16Array([1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0]),
        to = new Uint8Array([16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 64, 64]);
    var Ye = (e, n, t, i, r, a, o, s) => {
        const f = s.bits;
        let l = 0, c = 0, _ = 0, h = 0, u = 0, d = 0, p = 0, g = 0, b = 0, v = 0, x, m, k, C, y, I = null, w;
        const E = new Uint16Array(Ie + 1), A = new Uint16Array(Ie + 1);
        let ye = null, lr, At, Tt;
        for (l = 0; l <= Ie; l++) E[l] = 0;
        for (c = 0; c < i; c++) E[n[t + c]]++;
        for (u = f, h = Ie; h >= 1 && E[h] === 0; h--) ;
        if (u > h && (u = h), h === 0) return r[a++] = 1 << 24 | 64 << 16 | 0, r[a++] = 1 << 24 | 64 << 16 | 0, s.bits = 1, 0;
        for (_ = 1; _ < h && E[_] === 0; _++) ;
        for (u < _ && (u = _), g = 1, l = 1; l <= Ie; l++) if (g <<= 1, g -= E[l], g < 0) return -1;
        if (g > 0 && (e === ti || h !== 1)) return -1;
        for (A[1] = 0, l = 1; l < Ie; l++) A[l + 1] = A[l] + E[l];
        for (c = 0; c < i; c++) n[t + c] !== 0 && (o[A[n[t + c]]++] = c);
        if (e === ti ? (I = ye = o, w = 20) : e === Kt ? (I = Ja, ye = Qa, w = 257) : (I = eo, ye = to, w = 0), v = 0, c = 0, l = _, y = a, d = u, p = 0, k = -1, b = 1 << u, C = b - 1, e === Kt && b > Qn || e === ni && b > ei) return 1;
        for (; ;) {
            lr = l - p, o[c] + 1 < w ? (At = 0, Tt = o[c]) : o[c] >= w ? (At = ye[o[c] - w], Tt = I[o[c] - w]) : (At = 96, Tt = 0), x = 1 << l - p, m = 1 << d, _ = m;
            do m -= x, r[y + (v >> p) + m] = lr << 24 | At << 16 | Tt | 0; while (m !== 0);
            for (x = 1 << l - 1; v & x;) x >>= 1;
            if (x !== 0 ? (v &= x - 1, v += x) : v = 0, c++, --E[l] === 0) {
                if (l === h) break;
                l = n[t + o[c]]
            }
            if (l > u && (v & C) !== k) {
                for (p === 0 && (p = u), y += _, d = l - p, g = 1 << d; d + p < h && (g -= E[d + p], !(g <= 0));) d++, g <<= 1;
                if (b += 1 << d, e === Kt && b > Qn || e === ni && b > ei) return 1;
                k = v & C, r[k] = u << 24 | d << 16 | y - a | 0
            }
        }
        return v !== 0 && (r[y + v] = l - p << 24 | 64 << 16 | 0), s.bits = u, 0
    };
    const no = 0, ii = 1, ri = 2, {
            Z_FINISH: ai,
            Z_BLOCK: io,
            Z_TREES: ft,
            Z_OK: me,
            Z_STREAM_END: ro,
            Z_NEED_DICT: ao,
            Z_STREAM_ERROR: X,
            Z_DATA_ERROR: oi,
            Z_MEM_ERROR: si,
            Z_BUF_ERROR: oo,
            Z_DEFLATED: li
        } = He, ut = 16180, ci = 16181, fi = 16182, ui = 16183, di = 16184, hi = 16185, _i = 16186, mi = 16187, gi = 16188,
        pi = 16189, dt = 16190, te = 16191, Yt = 16192, wi = 16193, qt = 16194, bi = 16195, yi = 16196, xi = 16197,
        vi = 16198, ht = 16199, _t = 16200, Ei = 16201, Si = 16202, Ai = 16203, Ti = 16204, ki = 16205, Jt = 16206,
        Ri = 16207, Ii = 16208, O = 16209, Mi = 16210, Oi = 16211, so = 852, lo = 592, co = 15,
        Di = e => (e >>> 24 & 255) + (e >>> 8 & 65280) + ((e & 65280) << 8) + ((e & 255) << 24);

    function fo() {
        this.strm = null, this.mode = 0, this.last = !1, this.wrap = 0, this.havedict = !1, this.flags = 0, this.dmax = 0, this.check = 0, this.total = 0, this.head = null, this.wbits = 0, this.wsize = 0, this.whave = 0, this.wnext = 0, this.window = null, this.hold = 0, this.bits = 0, this.length = 0, this.offset = 0, this.extra = 0, this.lencode = null, this.distcode = null, this.lenbits = 0, this.distbits = 0, this.ncode = 0, this.nlen = 0, this.ndist = 0, this.have = 0, this.next = null, this.lens = new Uint16Array(320), this.work = new Uint16Array(288), this.lendyn = null, this.distdyn = null, this.sane = 0, this.back = 0, this.was = 0
    }

    const ge = e => {
        if (!e) return 1;
        const n = e.state;
        return !n || n.strm !== e || n.mode < ut || n.mode > Oi ? 1 : 0
    }, Ci = e => {
        if (ge(e)) return X;
        const n = e.state;
        return e.total_in = e.total_out = n.total = 0, e.msg = "", n.wrap && (e.adler = n.wrap & 1), n.mode = ut, n.last = 0, n.havedict = 0, n.flags = -1, n.dmax = 32768, n.head = null, n.hold = 0, n.bits = 0, n.lencode = n.lendyn = new Int32Array(so), n.distcode = n.distdyn = new Int32Array(lo), n.sane = 1, n.back = -1, me
    }, Ni = e => {
        if (ge(e)) return X;
        const n = e.state;
        return n.wsize = 0, n.whave = 0, n.wnext = 0, Ci(e)
    }, Fi = (e, n) => {
        let t;
        if (ge(e)) return X;
        const i = e.state;
        return n < 0 ? (t = 0, n = -n) : (t = (n >> 4) + 5, n < 48 && (n &= 15)), n && (n < 8 || n > 15) ? X : (i.window !== null && i.wbits !== n && (i.window = null), i.wrap = t, i.wbits = n, Ni(e))
    }, Pi = (e, n) => {
        if (!e) return X;
        const t = new fo;
        e.state = t, t.strm = e, t.window = null, t.mode = ut;
        const i = Fi(e, n);
        return i !== me && (e.state = null), i
    }, uo = e => Pi(e, co);
    let Li = !0, Qt, en;
    const ho = e => {
        if (Li) {
            Qt = new Int32Array(512), en = new Int32Array(32);
            let n = 0;
            for (; n < 144;) e.lens[n++] = 8;
            for (; n < 256;) e.lens[n++] = 9;
            for (; n < 280;) e.lens[n++] = 7;
            for (; n < 288;) e.lens[n++] = 8;
            for (Ye(ii, e.lens, 0, 288, Qt, 0, e.work, {bits: 9}), n = 0; n < 32;) e.lens[n++] = 5;
            Ye(ri, e.lens, 0, 32, en, 0, e.work, {bits: 5}), Li = !1
        }
        e.lencode = Qt, e.lenbits = 9, e.distcode = en, e.distbits = 5
    }, Ui = (e, n, t, i) => {
        let r;
        const a = e.state;
        return a.window === null && (a.wsize = 1 << a.wbits, a.wnext = 0, a.whave = 0, a.window = new Uint8Array(a.wsize)), i >= a.wsize ? (a.window.set(n.subarray(t - a.wsize, t), 0), a.wnext = 0, a.whave = a.wsize) : (r = a.wsize - a.wnext, r > i && (r = i), a.window.set(n.subarray(t - i, t - i + r), a.wnext), i -= r, i ? (a.window.set(n.subarray(t - i, t), 0), a.wnext = i, a.whave = a.wsize) : (a.wnext += r, a.wnext === a.wsize && (a.wnext = 0), a.whave < a.wsize && (a.whave += r))), 0
    }, _o = (e, n) => {
        let t, i, r, a, o, s, f, l, c, _, h, u, d, p, g = 0, b, v, x, m, k, C, y, I;
        const w = new Uint8Array(4);
        let E, A;
        const ye = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
        if (ge(e) || !e.output || !e.input && e.avail_in !== 0) return X;
        t = e.state, t.mode === te && (t.mode = Yt), o = e.next_out, r = e.output, f = e.avail_out, a = e.next_in, i = e.input, s = e.avail_in, l = t.hold, c = t.bits, _ = s, h = f, I = me;
        e:for (; ;) switch (t.mode) {
            case ut:
                if (t.wrap === 0) {
                    t.mode = Yt;
                    break
                }
                for (; c < 16;) {
                    if (s === 0) break e;
                    s--, l += i[a++] << c, c += 8
                }
                if (t.wrap & 2 && l === 35615) {
                    t.wbits === 0 && (t.wbits = 15), t.check = 0, w[0] = l & 255, w[1] = l >>> 8 & 255, t.check = N(t.check, w, 2, 0), l = 0, c = 0, t.mode = ci;
                    break
                }
                if (t.head && (t.head.done = !1), !(t.wrap & 1) || (((l & 255) << 8) + (l >> 8)) % 31) {
                    e.msg = "incorrect header check", t.mode = O;
                    break
                }
                if ((l & 15) !== li) {
                    e.msg = "unknown compression method", t.mode = O;
                    break
                }
                if (l >>>= 4, c -= 4, y = (l & 15) + 8, t.wbits === 0 && (t.wbits = y), y > 15 || y > t.wbits) {
                    e.msg = "invalid window size", t.mode = O;
                    break
                }
                t.dmax = 1 << t.wbits, t.flags = 0, e.adler = t.check = 1, t.mode = l & 512 ? pi : te, l = 0, c = 0;
                break;
            case ci:
                for (; c < 16;) {
                    if (s === 0) break e;
                    s--, l += i[a++] << c, c += 8
                }
                if (t.flags = l, (t.flags & 255) !== li) {
                    e.msg = "unknown compression method", t.mode = O;
                    break
                }
                if (t.flags & 57344) {
                    e.msg = "unknown header flags set", t.mode = O;
                    break
                }
                t.head && (t.head.text = l >> 8 & 1), t.flags & 512 && t.wrap & 4 && (w[0] = l & 255, w[1] = l >>> 8 & 255, t.check = N(t.check, w, 2, 0)), l = 0, c = 0, t.mode = fi;
            case fi:
                for (; c < 32;) {
                    if (s === 0) break e;
                    s--, l += i[a++] << c, c += 8
                }
                t.head && (t.head.time = l), t.flags & 512 && t.wrap & 4 && (w[0] = l & 255, w[1] = l >>> 8 & 255, w[2] = l >>> 16 & 255, w[3] = l >>> 24 & 255, t.check = N(t.check, w, 4, 0)), l = 0, c = 0, t.mode = ui;
            case ui:
                for (; c < 16;) {
                    if (s === 0) break e;
                    s--, l += i[a++] << c, c += 8
                }
                t.head && (t.head.xflags = l & 255, t.head.os = l >> 8), t.flags & 512 && t.wrap & 4 && (w[0] = l & 255, w[1] = l >>> 8 & 255, t.check = N(t.check, w, 2, 0)), l = 0, c = 0, t.mode = di;
            case di:
                if (t.flags & 1024) {
                    for (; c < 16;) {
                        if (s === 0) break e;
                        s--, l += i[a++] << c, c += 8
                    }
                    t.length = l, t.head && (t.head.extra_len = l), t.flags & 512 && t.wrap & 4 && (w[0] = l & 255, w[1] = l >>> 8 & 255, t.check = N(t.check, w, 2, 0)), l = 0, c = 0
                } else t.head && (t.head.extra = null);
                t.mode = hi;
            case hi:
                if (t.flags & 1024 && (u = t.length, u > s && (u = s), u && (t.head && (y = t.head.extra_len - t.length, t.head.extra || (t.head.extra = new Uint8Array(t.head.extra_len)), t.head.extra.set(i.subarray(a, a + u), y)), t.flags & 512 && t.wrap & 4 && (t.check = N(t.check, i, u, a)), s -= u, a += u, t.length -= u), t.length)) break e;
                t.length = 0, t.mode = _i;
            case _i:
                if (t.flags & 2048) {
                    if (s === 0) break e;
                    u = 0;
                    do y = i[a + u++], t.head && y && t.length < 65536 && (t.head.name += String.fromCharCode(y)); while (y && u < s);
                    if (t.flags & 512 && t.wrap & 4 && (t.check = N(t.check, i, u, a)), s -= u, a += u, y) break e
                } else t.head && (t.head.name = null);
                t.length = 0, t.mode = mi;
            case mi:
                if (t.flags & 4096) {
                    if (s === 0) break e;
                    u = 0;
                    do y = i[a + u++], t.head && y && t.length < 65536 && (t.head.comment += String.fromCharCode(y)); while (y && u < s);
                    if (t.flags & 512 && t.wrap & 4 && (t.check = N(t.check, i, u, a)), s -= u, a += u, y) break e
                } else t.head && (t.head.comment = null);
                t.mode = gi;
            case gi:
                if (t.flags & 512) {
                    for (; c < 16;) {
                        if (s === 0) break e;
                        s--, l += i[a++] << c, c += 8
                    }
                    if (t.wrap & 4 && l !== (t.check & 65535)) {
                        e.msg = "header crc mismatch", t.mode = O;
                        break
                    }
                    l = 0, c = 0
                }
                t.head && (t.head.hcrc = t.flags >> 9 & 1, t.head.done = !0), e.adler = t.check = 0, t.mode = te;
                break;
            case pi:
                for (; c < 32;) {
                    if (s === 0) break e;
                    s--, l += i[a++] << c, c += 8
                }
                e.adler = t.check = Di(l), l = 0, c = 0, t.mode = dt;
            case dt:
                if (t.havedict === 0) return e.next_out = o, e.avail_out = f, e.next_in = a, e.avail_in = s, t.hold = l, t.bits = c, ao;
                e.adler = t.check = 1, t.mode = te;
            case te:
                if (n === io || n === ft) break e;
            case Yt:
                if (t.last) {
                    l >>>= c & 7, c -= c & 7, t.mode = Jt;
                    break
                }
                for (; c < 3;) {
                    if (s === 0) break e;
                    s--, l += i[a++] << c, c += 8
                }
                switch (t.last = l & 1, l >>>= 1, c -= 1, l & 3) {
                    case 0:
                        t.mode = wi;
                        break;
                    case 1:
                        if (ho(t), t.mode = ht, n === ft) {
                            l >>>= 2, c -= 2;
                            break e
                        }
                        break;
                    case 2:
                        t.mode = yi;
                        break;
                    case 3:
                        e.msg = "invalid block type", t.mode = O
                }
                l >>>= 2, c -= 2;
                break;
            case wi:
                for (l >>>= c & 7, c -= c & 7; c < 32;) {
                    if (s === 0) break e;
                    s--, l += i[a++] << c, c += 8
                }
                if ((l & 65535) !== (l >>> 16 ^ 65535)) {
                    e.msg = "invalid stored block lengths", t.mode = O;
                    break
                }
                if (t.length = l & 65535, l = 0, c = 0, t.mode = qt, n === ft) break e;
            case qt:
                t.mode = bi;
            case bi:
                if (u = t.length, u) {
                    if (u > s && (u = s), u > f && (u = f), u === 0) break e;
                    r.set(i.subarray(a, a + u), o), s -= u, a += u, f -= u, o += u, t.length -= u;
                    break
                }
                t.mode = te;
                break;
            case yi:
                for (; c < 14;) {
                    if (s === 0) break e;
                    s--, l += i[a++] << c, c += 8
                }
                if (t.nlen = (l & 31) + 257, l >>>= 5, c -= 5, t.ndist = (l & 31) + 1, l >>>= 5, c -= 5, t.ncode = (l & 15) + 4, l >>>= 4, c -= 4, t.nlen > 286 || t.ndist > 30) {
                    e.msg = "too many length or distance symbols", t.mode = O;
                    break
                }
                t.have = 0, t.mode = xi;
            case xi:
                for (; t.have < t.ncode;) {
                    for (; c < 3;) {
                        if (s === 0) break e;
                        s--, l += i[a++] << c, c += 8
                    }
                    t.lens[ye[t.have++]] = l & 7, l >>>= 3, c -= 3
                }
                for (; t.have < 19;) t.lens[ye[t.have++]] = 0;
                if (t.lencode = t.lendyn, t.lenbits = 7, E = {bits: t.lenbits}, I = Ye(no, t.lens, 0, 19, t.lencode, 0, t.work, E), t.lenbits = E.bits, I) {
                    e.msg = "invalid code lengths set", t.mode = O;
                    break
                }
                t.have = 0, t.mode = vi;
            case vi:
                for (; t.have < t.nlen + t.ndist;) {
                    for (; g = t.lencode[l & (1 << t.lenbits) - 1], b = g >>> 24, v = g >>> 16 & 255, x = g & 65535, !(b <= c);) {
                        if (s === 0) break e;
                        s--, l += i[a++] << c, c += 8
                    }
                    if (x < 16) l >>>= b, c -= b, t.lens[t.have++] = x; else {
                        if (x === 16) {
                            for (A = b + 2; c < A;) {
                                if (s === 0) break e;
                                s--, l += i[a++] << c, c += 8
                            }
                            if (l >>>= b, c -= b, t.have === 0) {
                                e.msg = "invalid bit length repeat", t.mode = O;
                                break
                            }
                            y = t.lens[t.have - 1], u = 3 + (l & 3), l >>>= 2, c -= 2
                        } else if (x === 17) {
                            for (A = b + 3; c < A;) {
                                if (s === 0) break e;
                                s--, l += i[a++] << c, c += 8
                            }
                            l >>>= b, c -= b, y = 0, u = 3 + (l & 7), l >>>= 3, c -= 3
                        } else {
                            for (A = b + 7; c < A;) {
                                if (s === 0) break e;
                                s--, l += i[a++] << c, c += 8
                            }
                            l >>>= b, c -= b, y = 0, u = 11 + (l & 127), l >>>= 7, c -= 7
                        }
                        if (t.have + u > t.nlen + t.ndist) {
                            e.msg = "invalid bit length repeat", t.mode = O;
                            break
                        }
                        for (; u--;) t.lens[t.have++] = y
                    }
                }
                if (t.mode === O) break;
                if (t.lens[256] === 0) {
                    e.msg = "invalid code -- missing end-of-block", t.mode = O;
                    break
                }
                if (t.lenbits = 9, E = {bits: t.lenbits}, I = Ye(ii, t.lens, 0, t.nlen, t.lencode, 0, t.work, E), t.lenbits = E.bits, I) {
                    e.msg = "invalid literal/lengths set", t.mode = O;
                    break
                }
                if (t.distbits = 6, t.distcode = t.distdyn, E = {bits: t.distbits}, I = Ye(ri, t.lens, t.nlen, t.ndist, t.distcode, 0, t.work, E), t.distbits = E.bits, I) {
                    e.msg = "invalid distances set", t.mode = O;
                    break
                }
                if (t.mode = ht, n === ft) break e;
            case ht:
                t.mode = _t;
            case _t:
                if (s >= 6 && f >= 258) {
                    e.next_out = o, e.avail_out = f, e.next_in = a, e.avail_in = s, t.hold = l, t.bits = c, qa(e, h), o = e.next_out, r = e.output, f = e.avail_out, a = e.next_in, i = e.input, s = e.avail_in, l = t.hold, c = t.bits, t.mode === te && (t.back = -1);
                    break
                }
                for (t.back = 0; g = t.lencode[l & (1 << t.lenbits) - 1], b = g >>> 24, v = g >>> 16 & 255, x = g & 65535, !(b <= c);) {
                    if (s === 0) break e;
                    s--, l += i[a++] << c, c += 8
                }
                if (v && !(v & 240)) {
                    for (m = b, k = v, C = x; g = t.lencode[C + ((l & (1 << m + k) - 1) >> m)], b = g >>> 24, v = g >>> 16 & 255, x = g & 65535, !(m + b <= c);) {
                        if (s === 0) break e;
                        s--, l += i[a++] << c, c += 8
                    }
                    l >>>= m, c -= m, t.back += m
                }
                if (l >>>= b, c -= b, t.back += b, t.length = x, v === 0) {
                    t.mode = ki;
                    break
                }
                if (v & 32) {
                    t.back = -1, t.mode = te;
                    break
                }
                if (v & 64) {
                    e.msg = "invalid literal/length code", t.mode = O;
                    break
                }
                t.extra = v & 15, t.mode = Ei;
            case Ei:
                if (t.extra) {
                    for (A = t.extra; c < A;) {
                        if (s === 0) break e;
                        s--, l += i[a++] << c, c += 8
                    }
                    t.length += l & (1 << t.extra) - 1, l >>>= t.extra, c -= t.extra, t.back += t.extra
                }
                t.was = t.length, t.mode = Si;
            case Si:
                for (; g = t.distcode[l & (1 << t.distbits) - 1], b = g >>> 24, v = g >>> 16 & 255, x = g & 65535, !(b <= c);) {
                    if (s === 0) break e;
                    s--, l += i[a++] << c, c += 8
                }
                if (!(v & 240)) {
                    for (m = b, k = v, C = x; g = t.distcode[C + ((l & (1 << m + k) - 1) >> m)], b = g >>> 24, v = g >>> 16 & 255, x = g & 65535, !(m + b <= c);) {
                        if (s === 0) break e;
                        s--, l += i[a++] << c, c += 8
                    }
                    l >>>= m, c -= m, t.back += m
                }
                if (l >>>= b, c -= b, t.back += b, v & 64) {
                    e.msg = "invalid distance code", t.mode = O;
                    break
                }
                t.offset = x, t.extra = v & 15, t.mode = Ai;
            case Ai:
                if (t.extra) {
                    for (A = t.extra; c < A;) {
                        if (s === 0) break e;
                        s--, l += i[a++] << c, c += 8
                    }
                    t.offset += l & (1 << t.extra) - 1, l >>>= t.extra, c -= t.extra, t.back += t.extra
                }
                if (t.offset > t.dmax) {
                    e.msg = "invalid distance too far back", t.mode = O;
                    break
                }
                t.mode = Ti;
            case Ti:
                if (f === 0) break e;
                if (u = h - f, t.offset > u) {
                    if (u = t.offset - u, u > t.whave && t.sane) {
                        e.msg = "invalid distance too far back", t.mode = O;
                        break
                    }
                    u > t.wnext ? (u -= t.wnext, d = t.wsize - u) : d = t.wnext - u, u > t.length && (u = t.length), p = t.window
                } else p = r, d = o - t.offset, u = t.length;
                u > f && (u = f), f -= u, t.length -= u;
                do r[o++] = p[d++]; while (--u);
                t.length === 0 && (t.mode = _t);
                break;
            case ki:
                if (f === 0) break e;
                r[o++] = t.length, f--, t.mode = _t;
                break;
            case Jt:
                if (t.wrap) {
                    for (; c < 32;) {
                        if (s === 0) break e;
                        s--, l |= i[a++] << c, c += 8
                    }
                    if (h -= f, e.total_out += h, t.total += h, t.wrap & 4 && h && (e.adler = t.check = t.flags ? N(t.check, r, h, o - h) : Be(t.check, r, h, o - h)), h = f, t.wrap & 4 && (t.flags ? l : Di(l)) !== t.check) {
                        e.msg = "incorrect data check", t.mode = O;
                        break
                    }
                    l = 0, c = 0
                }
                t.mode = Ri;
            case Ri:
                if (t.wrap && t.flags) {
                    for (; c < 32;) {
                        if (s === 0) break e;
                        s--, l += i[a++] << c, c += 8
                    }
                    if (t.wrap & 4 && l !== (t.total & 4294967295)) {
                        e.msg = "incorrect length check", t.mode = O;
                        break
                    }
                    l = 0, c = 0
                }
                t.mode = Ii;
            case Ii:
                I = ro;
                break e;
            case O:
                I = oi;
                break e;
            case Mi:
                return si;
            case Oi:
            default:
                return X
        }
        return e.next_out = o, e.avail_out = f, e.next_in = a, e.avail_in = s, t.hold = l, t.bits = c, (t.wsize || h !== e.avail_out && t.mode < O && (t.mode < Jt || n !== ai)) && Ui(e, e.output, e.next_out, h - e.avail_out), _ -= e.avail_in, h -= e.avail_out, e.total_in += _, e.total_out += h, t.total += h, t.wrap & 4 && h && (e.adler = t.check = t.flags ? N(t.check, r, h, e.next_out - h) : Be(t.check, r, h, e.next_out - h)), e.data_type = t.bits + (t.last ? 64 : 0) + (t.mode === te ? 128 : 0) + (t.mode === ht || t.mode === qt ? 256 : 0), (_ === 0 && h === 0 || n === ai) && I === me && (I = oo), I
    }, mo = e => {
        if (ge(e)) return X;
        let n = e.state;
        return n.window && (n.window = null), e.state = null, me
    }, go = (e, n) => {
        if (ge(e)) return X;
        const t = e.state;
        return t.wrap & 2 ? (t.head = n, n.done = !1, me) : X
    }, po = (e, n) => {
        const t = n.length;
        let i, r, a;
        return ge(e) || (i = e.state, i.wrap !== 0 && i.mode !== dt) ? X : i.mode === dt && (r = 1, r = Be(r, n, t, 0), r !== i.check) ? oi : (a = Ui(e, n, t, t), a ? (i.mode = Mi, si) : (i.havedict = 1, me))
    };
    var wo = Ni, bo = Fi, yo = Ci, xo = uo, vo = Pi, Eo = _o, So = mo, Ao = go, To = po,
        ko = "pako inflate (from Nodeca project)", ne = {
            inflateReset: wo,
            inflateReset2: bo,
            inflateResetKeep: yo,
            inflateInit: xo,
            inflateInit2: vo,
            inflate: Eo,
            inflateEnd: So,
            inflateGetHeader: Ao,
            inflateSetDictionary: To,
            inflateInfo: ko
        };

    function Ro() {
        this.text = 0, this.time = 0, this.xflags = 0, this.os = 0, this.extra = null, this.extra_len = 0, this.name = "", this.comment = "", this.hcrc = 0, this.done = !1
    }

    var Io = Ro;
    const zi = Object.prototype.toString, {
        Z_NO_FLUSH: Mo,
        Z_FINISH: Oo,
        Z_OK: qe,
        Z_STREAM_END: tn,
        Z_NEED_DICT: nn,
        Z_STREAM_ERROR: Do,
        Z_DATA_ERROR: Bi,
        Z_MEM_ERROR: Co
    } = He;

    function rn(e) {
        this.options = st.assign({chunkSize: 1024 * 64, windowBits: 15, to: ""}, e || {});
        const n = this.options;
        n.raw && n.windowBits >= 0 && n.windowBits < 16 && (n.windowBits = -n.windowBits, n.windowBits === 0 && (n.windowBits = -15)), n.windowBits >= 0 && n.windowBits < 16 && !(e && e.windowBits) && (n.windowBits += 32), n.windowBits > 15 && n.windowBits < 48 && (n.windowBits & 15 || (n.windowBits |= 15)), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new qn, this.strm.avail_out = 0;
        let t = ne.inflateInit2(this.strm, n.windowBits);
        if (t !== qe) throw new Error(Ee[t]);
        if (this.header = new Io, ne.inflateGetHeader(this.strm, this.header), n.dictionary && (typeof n.dictionary == "string" ? n.dictionary = je.string2buf(n.dictionary) : zi.call(n.dictionary) === "[object ArrayBuffer]" && (n.dictionary = new Uint8Array(n.dictionary)), n.raw && (t = ne.inflateSetDictionary(this.strm, n.dictionary), t !== qe))) throw new Error(Ee[t])
    }

    rn.prototype.push = function (e, n) {
        const t = this.strm, i = this.options.chunkSize, r = this.options.dictionary;
        let a, o, s;
        if (this.ended) return !1;
        for (n === ~~n ? o = n : o = n === !0 ? Oo : Mo, zi.call(e) === "[object ArrayBuffer]" ? t.input = new Uint8Array(e) : t.input = e, t.next_in = 0, t.avail_in = t.input.length; ;) {
            for (t.avail_out === 0 && (t.output = new Uint8Array(i), t.next_out = 0, t.avail_out = i), a = ne.inflate(t, o), a === nn && r && (a = ne.inflateSetDictionary(t, r), a === qe ? a = ne.inflate(t, o) : a === Bi && (a = nn)); t.avail_in > 0 && a === tn && t.state.wrap > 0 && e[t.next_in] !== 0;) ne.inflateReset(t), a = ne.inflate(t, o);
            switch (a) {
                case Do:
                case Bi:
                case nn:
                case Co:
                    return this.onEnd(a), this.ended = !0, !1
            }
            if (s = t.avail_out, t.next_out && (t.avail_out === 0 || a === tn)) if (this.options.to === "string") {
                let f = je.utf8border(t.output, t.next_out), l = t.next_out - f, c = je.buf2string(t.output, f);
                t.next_out = l, t.avail_out = i - l, l && t.output.set(t.output.subarray(f, f + l), 0), this.onData(c)
            } else this.onData(t.output.length === t.next_out ? t.output : t.output.subarray(0, t.next_out));
            if (!(a === qe && s === 0)) {
                if (a === tn) return a = ne.inflateEnd(this.strm), this.onEnd(a), this.ended = !0, !0;
                if (t.avail_in === 0) break
            }
        }
        return !0
    }, rn.prototype.onData = function (e) {
        this.chunks.push(e)
    }, rn.prototype.onEnd = function (e) {
        e === qe && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = st.flattenChunks(this.chunks)), this.chunks = [], this.err = e, this.msg = this.strm.msg
    };
    const {Deflate: Lc, deflate: No, deflateRaw: Uc, gzip: zc} = Ka;
    var Fo = No, Hi;
    (function (e) {
        e.CHROME = "Google Chrome", e.FIREFOX = "Firefox", e.SAFARI = "Safari", e.CHROMIUM = "Chromium", e.OPERA = "Opera", e.EDGE = "Microsoft Edge", e.BRAVE = "Brave", e.UNKNOWN = "Unknown browser"
    })(Hi || (Hi = {}));
    var Zi;
    (function (e) {
        e.MAC = "Mac OS", e.LINUX = "Linux", e.WINDOWS = "Windows", e.CHROME = "Chrome OS", e.ANDROID = "Android", e.IOS = "iOS", e.UNKNOWN = "Unknown platform"
    })(Zi || (Zi = {}));
    var Vi;
    (function (e) {
        e.v1 = ";Not A Brand", e.v2 = " Not A;Brand", e.v3 = " Not;A Brand", e.v4 = ".Not/A)Brand", e.v5 = "Not;A=Brand", e.v6 = "Not=A?Brand", e.v7 = "Not?A_Brand", e.v8 = "Not_A Brand", e.v9 = "Not A(Brand", e.v10 = "Not(A:Brand", e.v11 = "Not:A-Brand", e.v12 = "Not-A.Brand", e.v13 = "Not.A/Brand", e.v14 = "Not/A)Brand", e.v15 = "Not)A;Brand"
    })(Vi || (Vi = {}));
    var Gi;
    (function (e) {
        e.VIEWER = "PDF Viewer", e.CHROME_PLUGIN = "Chrome PDF Plugin", e.CHROME_VIEWER = "Chrome PDF Viewer", e.NATIVE_CLIENT = "Native Client", e.CHROMIUM_PLUGIN = "Chromium PDF Plugin", e.CHROMIUM_VIEWER = "Chromium PDF Viewer", e.NEWS_FEED_HANDLER = "News feed handler", e.EDGE_PLUGIN = "Microsoft Edge PDF Plugin", e.EDGE_VIEWER = "Microsoft Edge PDF Viewer", e.WEBKIT_BUILTIN = "WebKit built-in PDF"
    })(Gi || (Gi = {}));
    var $i;
    (function (e) {
        e.ACCEPT_LANGUAGE = "accept-language", e.ARCHITECTURE = "sec-ch-ua-arch", e.BITNESS = "sec-ch-ua-bitness", e.BRANDS = "sec-ch-ua", e.CF_CONNECTING_IP = "cf-connecting-ip", e.DEVICE_MEMORY = "sec-ch-device-memory", e.FETCH_DEST = "sec-fetch-dest", e.FETCH_USER = "sec-fetch-user", e.FORM_FACTORS = "sec-ch-ua-form-factors", e.FULL_VERSION_LIST = "sec-ch-ua-full-version-list", e.MOBILE = "sec-ch-ua-mobile", e.MODEL = "sec-ch-ua-model", e.PLATFORM = "sec-ch-ua-platform", e.PLATFORM_VERSION = "sec-ch-ua-platform-version", e.REFERER = "referer", e.UA_FULL_VERSION = "sec-ch-ua-full-version", e.USER_AGENT = "user-agent", e.VIEW_PORT_HEIGHT = "sec-ch-viewport-height", e.VIEW_PORT_WIDTH = "sec-ch-viewport-width", e.WOW64 = "sec-ch-ua-wow64", e.X_FORWARDED_FOR = "x-forwarded-for", e.X_SSL_CIPHER = "x-ssl-cipher"
    })($i || ($i = {}));

    function P(e) {
        return (Object.prototype.toString.call(e).match(/^\[object (\S+?)]$/) || [])[1]?.toLowerCase() || "undefined"
    }

    const J = {
        isString: e => P(e) === "string",
        isNumber: e => P(e) === "number",
        isNumberFinity: e => Number.isFinite(e),
        isNegativeInfinity: e => e === Number.NEGATIVE_INFINITY,
        isPositiveInfinity: e => e === Number.POSITIVE_INFINITY,
        isNaN: e => Number.isNaN(e),
        isObject: e => P(e) === "object",
        isArray: e => P(e) === "array",
        isBoolean: e => P(e) === "boolean",
        isSymbol: e => P(e) === "symbol",
        isUndefined: e => P(e) === "undefined",
        isNull: e => P(e) === "null",
        isDate: e => P(e) === "date",
        isBigIng: e => P(e) === "bigint",
        isMap: e => P(e) === "map",
        isSet: e => P(e) === "set",
        isWeakMap: e => P(e) === "weakmap",
        isWeakSet: e => P(e) === "weakset",
        isRegExp: e => P(e) === "regexp",
        isFunc: e => ["asyncfunction", "function"].includes(P(e)),
        isError: e => P(e) === "error",
        isNil: e => J.isUndefined(e) || J.isNull(e)
    };

    function Je(e, n) {
        return J.isNil(e) ? !1 : Object.hasOwn(e, n) ? !0 : n in e
    }

    async function Po(e, n) {
        try {
            const t = await fetch(e, n);
            if (!t.ok) throw new Error(`HTTP error! Status: ${t.status}`);
            return await t.json()
        } catch (t) {
            throw console.error("Fetch error:", t), t
        }
    }

    Array.from({length: 256}, (e, n) => `00${n.toString(16)}`.slice(-2));

    function Lo() {
        return false
    }

    function Uo() {
        return !!window.ActiveXObject
    }

    function zo() {
        const e = new Float32Array(1), n = new Uint8Array(e.buffer);
        return e[0] = 1 / 0, e[0] -= e[0], n[3]
    }/*!
 * +----------------------------------------------------------------------------------+
 * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
 * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
 * |----------------------------------------------------------------------------------|
 * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
 * +----------------------------------------------------------------------------------+
 */
    const Bo = {hash128: $o}, Ho = {hash32: Vo, hash128: Go}, Xi = 3432918353, Wi = 461845907, mt = 597399067,
        gt = 2869860233, pt = 951274213, wt = 2716044179, bt = [2277735313, 289559509], yt = [1291169091, 658871167],
        Zo = Array.from({length: 256}, (e, n) => `00${n.toString(16)}`.slice(-2)),
        an = e => TextEncoder.prototype.encode.bind(new TextEncoder)(e);

    function Vo(e = new Uint8Array(0), n = 0, t = !0) {
        typeof e == "string" && (e = an(e));
        let i, r, a;
        if (typeof n == "number") i = n, r = 0, a = 0; else {
            ({h1: i, len: a} = n);
            const {rem: c} = n;
            if (c.byteLength === 0) r = 0; else if (c.byteLength + e.byteLength >= 4) {
                a += 4, r = 4 - c.byteLength;
                const _ = new Uint8Array(4), h = new DataView(_.buffer);
                _.set(c), _.set(e.subarray(0, r), c.byteLength), i = qi(i, h.getUint32(0, !0))
            } else {
                const _ = new Uint8Array(e.byteLength + c.byteLength);
                _.set(c), _.set(e, c.byteLength), e = _, r = 0
            }
        }
        const o = new DataView(e.buffer, e.byteOffset), s = (e.byteLength - r) % 4, f = e.byteLength - r - s;
        for (a += f; r < f; r += 4) i = qi(i, o.getUint32(r, !0));
        if (!t) return {h1: i, len: a, rem: e.slice(e.byteLength - s)};
        a += s;
        let l = 0;
        switch (s) {
            case 3:
                l ^= e[r + 2] << 16;
            case 2:
                l ^= e[r + 1] << 8;
            case 1:
                l ^= e[r], l = M(l, Xi), l = z(l, 15), l = M(l, Wi), i ^= l
        }
        return i ^= a & 4294967295, i = Qe(i), i >>> 0
    }

    function Go(e = new Uint8Array(0), n = 0, t = !0) {
        let i;
        typeof e == "string" ? (e = an(e), i = !0) : i = !1;
        let r, a, o, s, f, l;
        if (typeof n == "number") r = a = o = s = n, f = 0, l = 0; else {
            ({h1: r, h2: a, h3: o, h4: s, len: l} = n);
            const {rem: v} = n;
            if (v.byteLength === 0) f = 0; else if (v.byteLength + e.byteLength >= 16) {
                l += 16, f = 16 - v.byteLength;
                const x = new Uint8Array(16), m = new DataView(x.buffer);
                x.set(v), x.set(e.subarray(0, f), v.byteLength), [r, a, o, s] = ji(r, a, o, s, m.getUint32(0, !0), m.getUint32(4, !0), m.getUint32(8, !0), m.getUint32(12, !0))
            } else {
                const x = new Uint8Array(e.byteLength + v.byteLength);
                x.set(v), x.set(e, v.byteLength), e = x, f = 0
            }
        }
        const c = new DataView(e.buffer, e.byteOffset), _ = (e.byteLength - f) % 16, h = e.byteLength - f - _;
        for (l += h; f < h; f += 16) [r, a, o, s] = ji(r, a, o, s, c.getUint32(f, !0), c.getUint32(f + 4, !0), c.getUint32(f + 8, !0), c.getUint32(f + 12, !0));
        if (!t) return {h1: r, h2: a, h3: o, h4: s, len: l, rem: e.subarray(e.byteLength - _)};
        l += _;
        let u = 0, d = 0, p = 0, g = 0;
        switch (_) {
            case 15:
                g ^= e[f + 14] << 16;
            case 14:
                g ^= e[f + 13] << 8;
            case 13:
                g ^= e[f + 12], g = M(g, wt), g = z(g, 18), g = M(g, mt), s ^= g;
            case 12:
                p ^= e[f + 11] << 24;
            case 11:
                p ^= e[f + 10] << 16;
            case 10:
                p ^= e[f + 9] << 8;
            case 9:
                p ^= e[f + 8], p = M(p, pt), p = z(p, 17), p = M(p, wt), o ^= p;
            case 8:
                d ^= e[f + 7] << 24;
            case 7:
                d ^= e[f + 6] << 16;
            case 6:
                d ^= e[f + 5] << 8;
            case 5:
                d ^= e[f + 4], d = M(d, gt), d = z(d, 16), d = M(d, pt), a ^= d;
            case 4:
                u ^= e[f + 3] << 24;
            case 3:
                u ^= e[f + 2] << 16;
            case 2:
                u ^= e[f + 1] << 8;
            case 1:
                u ^= e[f], u = M(u, mt), u = z(u, 15), u = M(u, gt), r ^= u
        }
        r ^= l & 4294967295, a ^= l & 4294967295, o ^= l & 4294967295, s ^= l & 4294967295, r += a + o + s, a += r, o += r, s += r, r = Qe(r), a = Qe(a), o = Qe(o), s = Qe(s), r += a + o + s, a += r, o += r, s += r;
        const b = new DataView(new ArrayBuffer(16));
        return b.setUint32(0, r, !1), b.setUint32(4, a, !1), b.setUint32(8, o, !1), b.setUint32(12, s, !1), i ? on(new Uint8Array(b.buffer)) : new Uint8Array(b.buffer)
    }

    function $o(e = new Uint8Array(0), n = 0, t = !0) {
        let i;
        typeof e == "string" ? (e = an(e), i = !0) : i = !1;
        let r, a, o, s;
        if (typeof n == "number") r = [0, n], a = [0, n], o = 0, s = 0; else {
            ({h1: r, h2: a, len: s} = n);
            const {rem: d} = n;
            if (d.byteLength === 0) o = 0; else if (d.byteLength + e.byteLength >= 16) {
                s += 16, o = 16 - d.byteLength;
                const p = new Uint8Array(16), g = new DataView(p.buffer);
                p.set(d), p.set(e.subarray(0, o), d.byteLength), [r, a] = Yi(r, a, [g.getUint32(4, !0), g.getUint32(0, !0)], [g.getUint32(12, !0), g.getUint32(8, !0)])
            } else {
                const p = new Uint8Array(e.byteLength + d.byteLength);
                p.set(d), p.set(e, d.byteLength), e = p, o = 0
            }
        }
        const f = new DataView(e.buffer, e.byteOffset), l = (e.byteLength - o) % 16, c = e.byteLength - o - l;
        for (s += c; o < c; o += 16) [r, a] = Yi(r, a, [f.getUint32(o + 4, !0), f.getUint32(o, !0)], [f.getUint32(o + 12, !0), f.getUint32(o + 8, !0)]);
        if (!t) return {h1: r, h2: a, len: s, rem: e.subarray(e.byteLength - l)};
        s += l;
        let _ = [0, 0], h = [0, 0];
        switch (l) {
            case 15:
                h = D(h, G([0, e[o + 14]], 48));
            case 14:
                h = D(h, G([0, e[o + 13]], 40));
            case 13:
                h = D(h, G([0, e[o + 12]], 32));
            case 12:
                h = D(h, G([0, e[o + 11]], 24));
            case 11:
                h = D(h, G([0, e[o + 10]], 16));
            case 10:
                h = D(h, G([0, e[o + 9]], 8));
            case 9:
                h = D(h, [0, e[o + 8]]), h = W(h, yt), h = Me(h, 33), h = W(h, bt), a = D(a, h);
            case 8:
                _ = D(_, G([0, e[o + 7]], 56));
            case 7:
                _ = D(_, G([0, e[o + 6]], 48));
            case 6:
                _ = D(_, G([0, e[o + 5]], 40));
            case 5:
                _ = D(_, G([0, e[o + 4]], 32));
            case 4:
                _ = D(_, G([0, e[o + 3]], 24));
            case 3:
                _ = D(_, G([0, e[o + 2]], 16));
            case 2:
                _ = D(_, G([0, e[o + 1]], 8));
            case 1:
                _ = D(_, [0, e[o]]), _ = W(_, bt), _ = Me(_, 31), _ = W(_, yt), r = D(r, _)
        }
        r = D(r, [0, s & 4294967295]), a = D(a, [0, s & 4294967295]), r = ce(r, a), a = ce(a, r), r = Ki(r), a = Ki(a), r = ce(r, a), a = ce(a, r);
        const u = new DataView(new ArrayBuffer(16));
        return u.setUint32(0, r[0], !1), u.setUint32(4, r[1], !1), u.setUint32(8, a[0], !1), u.setUint32(12, a[1], !1), i ? on(new Uint8Array(u.buffer)) : new Uint8Array(u.buffer)
    }

    function ji(e, n, t, i, r, a, o, s) {
        return r = M(r, mt), r = z(r, 15), r = M(r, gt), e ^= r, e = z(e, 19), e += n, e = M(e, 5) + 1444728091, a = M(a, gt), a = z(a, 16), a = M(a, pt), n ^= a, n = z(n, 17), n += t, n = M(n, 5) + 197830471, o = M(o, pt), o = z(o, 17), o = M(o, wt), t ^= o, t = z(t, 15), t += i, t = M(t, 5) + 2530024501, s = M(s, wt), s = z(s, 18), s = M(s, mt), i ^= s, i = z(i, 13), i += e, i = M(i, 5) + 850148119, [e, n, t, i]
    }

    function Ki(e) {
        return e = D(e, [0, e[0] >>> 1]), e = W(e, [4283543511, 3981806797]), e = D(e, [0, e[0] >>> 1]), e = W(e, [3301882366, 444984403]), e = D(e, [0, e[0] >>> 1]), e
    }

    function Yi(e, n, t, i) {
        return t = W(t, bt), t = Me(t, 31), t = W(t, yt), e = D(e, t), e = Me(e, 27), e = ce(e, n), e = ce(W(e, [0, 5]), [0, 1390208809]), i = W(i, yt), i = Me(i, 33), i = W(i, bt), n = D(n, i), n = Me(n, 31), n = ce(n, e), n = ce(W(n, [0, 5]), [0, 944331445]), [e, n]
    }

    function ce(e, n) {
        const t = [e[0] >>> 16, e[0] & 65535, e[1] >>> 16, e[1] & 65535],
            i = [n[0] >>> 16, n[0] & 65535, n[1] >>> 16, n[1] & 65535], r = [0, 0, 0, 0];
        return r[3] += t[3] + i[3], r[2] += r[3] >>> 16, r[3] &= 65535, r[2] += t[2] + i[2], r[1] += r[2] >>> 16, r[2] &= 65535, r[1] += t[1] + i[1], r[0] += r[1] >>> 16, r[1] &= 65535, r[0] += t[0] + i[0], r[0] &= 65535, [r[0] << 16 | r[1], r[2] << 16 | r[3]]
    }

    function W(e, n) {
        const t = [e[0] >>> 16, e[0] & 65535, e[1] >>> 16, e[1] & 65535],
            i = [n[0] >>> 16, n[0] & 65535, n[1] >>> 16, n[1] & 65535], r = [0, 0, 0, 0];
        return r[3] += t[3] * i[3], r[2] += r[3] >>> 16, r[3] &= 65535, r[2] += t[2] * i[3], r[1] += r[2] >>> 16, r[2] &= 65535, r[2] += t[3] * i[2], r[1] += r[2] >>> 16, r[2] &= 65535, r[1] += t[1] * i[3], r[0] += r[1] >>> 16, r[1] &= 65535, r[1] += t[2] * i[2], r[0] += r[1] >>> 16, r[1] &= 65535, r[1] += t[3] * i[1], r[0] += r[1] >>> 16, r[1] &= 65535, r[0] += t[0] * i[3] + t[1] * i[2] + t[2] * i[1] + t[3] * i[0], r[0] &= 65535, [r[0] << 16 | r[1], r[2] << 16 | r[3]]
    }

    function Me(e, n) {
        return n %= 64, n === 32 ? [e[1], e[0]] : n < 32 ? [e[0] << n | e[1] >>> 32 - n, e[1] << n | e[0] >>> 32 - n] : (n -= 32, [e[1] << n | e[0] >>> 32 - n, e[0] << n | e[1] >>> 32 - n])
    }

    function G(e, n) {
        return n %= 64, n === 0 ? e : n < 32 ? [e[0] << n | e[1] >>> 32 - n, e[1] << n] : [e[1] << n - 32, 0]
    }

    function Qe(e) {
        return e ^= e >>> 16, e = M(e, 2246822507), e ^= e >>> 13, e = M(e, 3266489909), e ^= e >>> 16, e
    }

    function qi(e, n) {
        return n = M(n, Xi), n = z(n, 15), n = M(n, Wi), e ^= n, e = z(e, 13), e = M(e, 5) + 3864292196, e
    }

    function D(e, n) {
        return [e[0] ^ n[0], e[1] ^ n[1]]
    }

    function on(e = new Uint8Array(0)) {
        let n = "";
        for (let t = 0; t < e.byteLength; t++) n += Zo[e[t]];
        return n
    }

    function M(e, n) {
        return (e & 65535) * n + (((e >>> 16) * n & 65535) << 16)
    }

    function z(e, n) {
        return e << n | e >>> 32 - n
    }

    function L(e) {
        return (Object.prototype.toString.call(e).match(/^\[object (\S+?)\]$/) || [])[1]?.toLowerCase() || "undefined"
    }

    const B = {
        isString: e => L(e) === "string",
        isNumber: e => L(e) === "number",
        isNumberFinity: e => Number.isFinite(e),
        isNegativeInfinity: e => e === Number.NEGATIVE_INFINITY,
        isPositiveInfinity: e => e === Number.POSITIVE_INFINITY,
        isNaN: e => Number.isNaN(e),
        isObject: e => L(e) === "object",
        isArray: e => L(e) === "array",
        isBoolean: e => L(e) === "boolean",
        isSymbol: e => L(e) === "symbol",
        isUndefined: e => L(e) === "undefined",
        isNull: e => L(e) === "null",
        isDate: e => L(e) === "date",
        isBigIng: e => L(e) === "bigint",
        isMap: e => L(e) === "map",
        isSet: e => L(e) === "set",
        isWeakMap: e => L(e) === "weakmap",
        isWeakSet: e => L(e) === "weakset",
        isRegExp: e => L(e) === "regexp",
        isFunc: e => ["asyncfunction", "function"].includes(L(e)),
        isError: e => L(e) === "error",
        isNil: e => B.isUndefined(e) || B.isNull(e)
    };

    function sn(e) {
        return e ? [...e].reduce((n, t) => n += Math.abs(t), 0) : 0
    }

    function et(e, n) {
        return new Promise(t => {
            setTimeout(t, e, n)
        })
    }

    function ln(e) {
        if (!B.isString(e)) throw new TypeError("Expected a string");
        return e && Ho.hash128(e).slice(0, 10)
    }

    function Ji(e) {
        return parseInt(e, 10)
    }

    function Q(e) {
        return parseFloat(e)
    }

    function pe(e, n) {
        return B.isNumber(e) && Number.isNaN(e) ? n : e
    }

    function Oe(e) {
        return e.reduce((n, t) => n + (t ? 1 : 0), 0)
    }

    function S(e, n) {
        return B.isNil(e) ? !1 : Object.hasOwn(e, n) ? !0 : n in e
    }

    function Xo(e) {
        return /^function\s.*?\{\s*\[native code]\s*}$/.test(String(e))
    }

    function ie(e, n) {
        return n ? matchMedia(`(${e}: ${n})`).matches : t => matchMedia(`(${e}: ${t})`).matches
    }

    class Wo extends Error {
        data;
        response;
        status;

        constructor(n, t) {
            super(`Request failed with status ${n.status}`), this.data = t, this.name = "ResponseError", this.response = n, this.status = n.status
        }
    }

    async function jo(e, n) {
        const t = await fetch(e, n), i = await t.json();
        if (t.ok) return i;
        throw new Wo(t, i)
    }

    function Ko(e, n = 1) {
        if (Math.abs(n) >= 1) return Math.round(e / n) * n;
        const t = 1 / n;
        return Math.round(e * t) / t
    }

    function Yo() {
        return document.fullscreenElement || document.msFullscreenElement || document.mozFullScreenElement || document.webkitFullscreenElement || null
    }

    function qo() {
        return (document.exitFullscreen || document.msExitFullscreen || document.mozCancelFullScreen || document.webkitExitFullscreen).call(document)
    }

    function Jo(e, n) {
        return B.isObject(e) ? Object.fromEntries(Object.entries(e).map(([t, i]) => {
            if (B.isObject(i)) {
                const r = Object.fromEntries(Object.entries(i).filter(([a]) => !n.includes(a)));
                return [t, r]
            }
            return [t, i]
        })) : e
    }

    async function xt({action: e, initialHtml: n, domPollInterval: t = 50}, ...i) {
        for (; !document.body;) await et(t);
        const r = document.createElement("iframe");
        try {
            for (await new Promise((a, o) => {
                let s = !1;
                const f = () => {
                    s = !0, a()
                }, l = h => {
                    s = !0, o(h)
                };
                r.onload = f, r.onerror = l;
                const {style: c} = r;
                c.setProperty("display", "block", "important"), c.position = "absolute", c.top = "0", c.left = "0", c.visibility = "hidden", n && "srcdoc" in r ? r.srcdoc = n : r.src = "about:blank", document.body.appendChild(r);
                const _ = () => {
                    s || (r.contentWindow?.document?.readyState === "complete" ? f() : setTimeout(_, 10))
                };
                _()
            }); !r.contentWindow?.document?.body;) await et(t);
            return await e(r, r.contentWindow, ...i)
        } finally {
            r.parentNode?.removeChild(r)
        }
    }

    const Qi = Math.random();

    function Qo(e, n) {
        return Math.floor(Math.random() * (n - e + 1)) + e
    }

    function es(e, n, t) {
        const {length: i} = n, r = 20, a = Qo(275, i - (r + 1)), o = a + r / 2, s = a + r;
        n.getChannelData(0)[a] = e, n.getChannelData(0)[o] = e, n.getChannelData(0)[s] = e, n.copyFromChannel(t, 0);
        const f = [n.getChannelData(0)[a] === 0 ? Math.random() : 0, n.getChannelData(0)[o] === 0 ? Math.random() : 0, n.getChannelData(0)[s] === 0 ? Math.random() : 0],
            l = [...n.getChannelData(0), ...t, ...f];
        return [...new Set(l)].filter(c => c !== 0)
    }

    function ts(e, n, t) {
        const i = t.map(() => e);
        n.copyToChannel(i, 0);
        const r = n.getChannelData(0), [a] = r;
        return [...r].map(o => o !== a || o === 0 ? Math.random() : o).filter(o => o !== a)
    }

    function ns(e) {
        return new Promise(n => {
            const t = e.createAnalyser(), i = e.createOscillator(), r = e.createDynamicsCompressor();
            try {
                i.type = "triangle", i.frequency.value = 1e4, r.threshold.value = -50, r.knee.value = 40, r.attack.value = 0
            } catch {
            }
            i.connect(r), r.connect(t), r.connect(e.destination), i.start(0), e.startRendering(), e.addEventListener("complete", a => {
                try {
                    r.disconnect(), i.disconnect();
                    const o = new Float32Array(t.frequencyBinCount);
                    t.getFloatFrequencyData(o);
                    const s = new Float32Array(t.fftSize);
                    return S(t, "getFloatTimeDomainData") && t.getFloatTimeDomainData(s), n({
                        floatFrequencyData: o,
                        floatTimeDomainData: s,
                        buffer: a.renderedBuffer,
                        compressorGainReduction: r.reduction.value || r.reduction
                    })
                } catch {
                    return n(null)
                }
            })
        })
    }

    function is() {
        const e = new OfflineAudioContext(1, 100, 44100), n = e.createOscillator();
        return n.frequency.value = 0, n.start(0), e.startRendering(), new Promise(t => {
            const i = setTimeout(() => t(!1), 2500);
            e.oncomplete = r => {
                clearTimeout(i);
                const a = r.renderedBuffer.getChannelData?.(0);
                if (!a) {
                    t(!1);
                    return
                }
                const o = `${[...new Set(a)]}` != "0";
                t(o)
            }
        }).finally(() => n.disconnect())
    }

    function rs() {
        try {
            const e = new AudioBuffer({length: 2e3, sampleRate: 44100}), n = new Float32Array(2e3), t = es(Qi, e, n),
                i = ts(Qi, e, n), r = [...new Set([...t, ...i])], a = r.reduce((o, s) => o + +s, 0);
            return +(r.length !== 1 && a)
        } catch {
            return 0
        }
    }

    function cn(e, n, t) {
        const i = [];
        for (let r = n; r < t; r++) i.push(e[r]);
        return i
    }

    async function as() {
        try {
            window.OfflineAudioContext = OfflineAudioContext || webkitOfflineAudioContext
        } catch {
        }
        if (!window.OfflineAudioContext) return null;
        const e = 5e3, n = {sampleNoiseDetected: !1, channelDataMismatch: !1, audioFake: !1, unexpectedFrequency: !1},
            t = new OfflineAudioContext(1, e, 44100), i = t.createAnalyser(), r = t.createOscillator(),
            a = t.createDynamicsCompressor(), o = t.createBiquadFilter(), s = new Float32Array(i.frequencyBinCount);
        i.getFloatFrequencyData?.(s), new Set(s).size > 1 && (n.unexpectedFrequency = !0);
        const [f, l] = await Promise.all([ns(new OfflineAudioContext(1, e, 44100)), is().catch(() => !1)]);
        l && (n.audioFake = !0);
        const {floatFrequencyData: c, floatTimeDomainData: _, buffer: h, compressorGainReduction: u} = f || {},
            d = sn(c), p = sn(_), g = new Float32Array(e);
        let b = new Float32Array;
        h && (h.copyFromChannel(g, 0), b = h.getChannelData(0) || []);
        const v = cn([...g], 4500, 4600), x = cn([...b], 4500, 4600), m = sn(cn([...b], 4500, e)), k = `${x}` == `${v}`;
        "copyFromChannel" in AudioBuffer.prototype && !k && (n.channelDataMismatch = !0);
        const C = new Set([...b]).size, y = rs() || [...new Set(b.slice(0, 100))].reduce((E, A) => E += A, 0);
        y && (n.sampleNoiseDetected = !0);
        const I = B.isUndefined(x[0]) ? null : ln(`${x}`), w = B.isUndefined(v[0]) ? null : ln(`${v}`);
        return {
            lies: n,
            noise: y,
            binsSample: I,
            copySample: w,
            sampleSum: m || null,
            totalUniqueSamples: C,
            compressorGainReduction: u || null,
            floatFrequencyDataSum: d || null,
            floatTimeDomainDataSum: p || null,
            analyserNode: {
                channelCount: i.channelCount,
                channelCountMode: i.channelCountMode,
                channelInterpretation: i.channelInterpretation,
                fftSize: i.fftSize,
                frequencyBinCount: i.frequencyBinCount,
                maxDecibels: i.maxDecibels,
                minDecibels: i.minDecibels,
                numberOfInputs: i.numberOfInputs,
                numberOfOutputs: i.numberOfOutputs,
                smoothingTimeConstant: i.smoothingTimeConstant,
                context: {
                    sampleRate: i.context.sampleRate,
                    listener: {forwardX: {maxValue: i.context.listener.forwardX.maxValue}}
                }
            },
            biquadFilterNode: {
                gain: {maxValue: o.gain.maxValue},
                frequency: {defaultValue: o.frequency.defaultValue, maxValue: o.frequency.maxValue}
            },
            dynamicsCompressorNode: {
                attack: {defaultValue: a.attack.defaultValue},
                knee: {defaultValue: a.knee.defaultValue, maxValue: a.knee.maxValue},
                ratio: {defaultValue: a.ratio.defaultValue, maxValue: a.ratio.maxValue},
                release: {defaultValue: a.release.defaultValue, maxValue: a.release.maxValue},
                threshold: {defaultValue: a.threshold.defaultValue, minValue: a.threshold.minValue}
            },
            oscillatorNode: {
                detune: {maxValue: r.detune.maxValue, minValue: r.detune.minValue},
                frequency: {
                    defaultValue: r.frequency.defaultValue,
                    maxValue: r.frequency.maxValue,
                    minValue: r.frequency.minValue
                }
            }
        }
    }

    function os() {
        const e = window.AudioContext || window.webkitAudioContext;
        return e ? new e().baseLatency ?? null : null
    }

    function ss() {
        return !!S(navigator, "getBattery")
    }

    function ls() {
        return S(navigator, "bluetooth")
    }

    const cs = ["AbortSignal", "Array", "ArrayBuffer", "Atomics", "BigInt", "Boolean", "Date", "Document", "Element", "Error", "Function", "GPU", "Intl", "JSON", "Map", "Math", "Navigation", "Navigator", "Number", "Object", "PerformanceNavigationTiming", "Promise", "Proxy", "RTCRtpReceiver", "ReadableStream", "Reflect", "RegExp", "SVGAElement", "Set", "ShadowRoot", "String", "Symbol", "WeakMap", "WeakSet", "WebAssembly", "WebSocketStream"];

    function fs() {
        const e = {};
        for (const n of cs) if (S(window, n)) {
            const t = window[n], i = Object.getOwnPropertyNames(t).filter(r => B.isFunc(t[r]));
            e[n] = i
        }
        return e
    }

    var we = (e => (e.Unsupported = "unsupported", e.Skipped = "skipped", e.Unstable = "unstable", e))(we || {}),
        tt = (e => (e[e.Less = -1] = "Less", e[e.None = 0] = "None", e[e.More = 1] = "More", e[e.ForcedColors = 10] = "ForcedColors", e))(tt || {});

    async function us(e, n) {
        ds(e, n), await et(0);
        const t = e.toDataURL(), i = e.toDataURL();
        return t !== i ? [we.Unstable, we.Unstable] : (hs(e, n), await et(0), [e.toDataURL(), t])
    }

    function ds(e, n) {
        e.width = 240, e.height = 60, n.textBaseline = "alphabetic", n.fillStyle = "#f60", n.fillRect(100, 1, 62, 20), n.fillStyle = "#069", n.font = '11pt "Times New Roman"';
        const t = "Cwm fjordbank gly 😃";
        n.fillText(t, 2, 15), n.fillStyle = "rgba(102, 204, 0, 0.2)", n.font = "18pt Arial", n.fillText(t, 4, 45)
    }

    function hs(e, n) {
        e.width = 122, e.height = 110, n.globalCompositeOperation = "multiply";
        for (const [t, i, r] of [["#f2f", 40, 40], ["#2ff", 80, 40], ["#ff2", 60, 80]]) n.fillStyle = t, n.beginPath(), n.arc(i, r, 40, 0, Math.PI * 2, !0), n.closePath(), n.fill();
        n.fillStyle = "#f9c", n.arc(60, 60, 60, 0, Math.PI * 2, !0), n.arc(60, 60, 20, 0, Math.PI * 2, !0), n.fill("evenodd")
    }

    function _s() {
        const e = document.createElement("canvas");
        return e.width = 1, e.height = 1, [e, e.getContext("2d")]
    }

    function ms(e) {
        return e.rect(0, 0, 10, 10), e.rect(2, 2, 6, 6), !e.isPointInPath(5, 5, "evenodd")
    }

    function er() {
        return Oe([S(window, "MSCSSMatrix"), S(window, "msSetImmediate"), S(window, "msIndexedDB"), S(navigator, "msMaxTouchPoints"), S(navigator, "msPointerEnabled")]) >= 4
    }

    function gs() {
        return Oe([S(window, "msWriteProfilerMark"), S(window, "MSStream"), S(navigator, "msLaunchUri"), S(navigator, "msSaveBlob")]) >= 3 && !er()
    }

    function fn() {
        return Xo(window.print) ? Oe([String(window.browser) === "[object WebPageNamespace]", S(window, "MicrodataExtractor")]) >= 1 : !1
    }

    function vt() {
        return Oe([S(window, "ApplePayError"), S(window, "CSSPrimitiveValue"), S(window, "WebKitMediaKeys"), S(window, "Counter"), S(navigator, "getStorageUpdates"), navigator.vendor.indexOf("Apple") === 0]) >= 4
    }

    function un() {
        const {CSS: e, HTMLButtonElement: n} = window;
        return Oe([S(window, "CSSCounterStyleRule"), !S(navigator, "getStorageUpdates"), n && S(n.prototype, "popover"), e.supports("font-size-adjust: ex-height 0.5"), e.supports("text-transform: full-width")]) >= 4
    }

    function ps() {
        return Oe([S(window, "webkitResolveLocalFileSystemURL"), S(window, "BatteryManager"), S(window, "webkitMediaStream"), S(window, "webkitSpeechGrammar"), S(navigator, "webkitPersistentStorage"), S(navigator, "webkitTemporaryStorage"), navigator.vendor.indexOf("Google") === 0]) >= 5
    }

    async function ws() {
        let e = !1, n, t;
        const [i, r] = _s();
        return r && i.toDataURL ? (e = ms(r), vt() && un() && fn() ? (n = we.Skipped, t = we.Skipped) : [n, t] = await us(i, r)) : (n = we.Unsupported, t = we.Unsupported), {
            winding: e,
            geometry: n,
            text: t
        }
    }

    const bs = {
        simpleTest: {
            style: `
      border: solid 2.715px green;
      padding: 3.98px;
      margin-left: 12.12px;
    `, block: "<div>Simple Test (1)</div>"
        }, transformTest: {
            style: `
      border: solid 2px purple;
      font-size: 30px;
      margin-top: 200px;
      -webkit-transform: skewY(23.1753218deg);
      -moz-transform: skewY(23.1753218deg);
      -ms-transform: skewY(23.1753218deg);
      -o-transform: skewY(23.1753218deg);
      transform: skewY(23.1753218deg);
    `, block: "<div>Transformation Test (2)</div>"
        }, scaleTest: {
            style: `
      border: solid 2.89px orange;
      font-size: 45px;
      transform: scale(100000000000000000000009999999999999.99, 1.89);
      margin-top: 50px;
    `, block: "<div>WW&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Scale Test (3)</div>"
        }, vendorSpecificTransformationTest: {
            style: `
      border: solid 2px silver;
      transform: matrix(1.11, 2.0001, -1.0001, 1.009, 150, 94.4);
      -webkit-transform: matrix(0.95559, 2.13329, -0.9842, 0.98423, 150, 95);
      -moz-transform: matrix(
        0.66371,
        1.94587,
        -0.6987,
        0.98423,
        150,
        103.238
      );
      -ms-transform: matrix(0.5478, 1.94587, -0.7383, 0.98423, 150, 100.569);
      -o-transform: matrix(0.4623, 1.83523, -0.6734, 0.81231, 150, 99.324);
      position: absolute;
      margin-top: 11.1331px;
      margin-left: 12.1212px;
      padding: 4.4545px;
      left: 239.4141px;
      top: 178.505px;
    `, block: "<div>Vendor specific transformation Test (4)</div>"
        }, tableCaptionTest: {
            style: `
      border: solid 2pt red;
      margin-left: 42.395pt;
    `, block: `
      <table>
        <caption>Table caption Test (5)</caption>
        <thead><tr><th>Table head</th></tr></thead>
        <tbody><tr><td>Table body</td></tr></tbody>
      </table>
    `
        }, transformPerspectiveTest: {
            style: `
      border: solid 2px darkblue;
      -webkit-transform: perspective(12890px) translateZ(101.5px);
      -moz-transform: perspective(12890px) translateZ(101.5px);
      -ms-transform: perspective(12890px) translateZ(101.5px);
      -o-transform: perspective(12890px) translateZ(101.5px);
      transform: perspective(12890px) translateZ(101.5px);
      padding: 12px;
    `, block: "<div>transform: perspective(12890px) translateZ(101.5px); Test (6)</div>"
        }, selectionOptionTest: {
            style: `
      position: absolute;
      margin-top: -350.552px;
      margin-left: 0.9099rem;
      border: solid 2px burlywood;
    `, block: `
      <div>
        <select>
            <option>selection-option (Test 7)</option>
        </select>
      </div>
    `
        }, detailSummaryTest: {
            style: `
      position: absolute;
      margin-top: -150.552px;
      margin-left: 15.9099rem;
      border: solid 2px sandybrown;
    `, block: `
      <div>
        <details>
          <summary>detail summary (Test 8)</summary>
        </details>
      </div>
    `
        }, progressTest: {
            style: `
      position: absolute;
      margin-top: -110.552px;
      margin-left: 15.9099rem;
      border: solid 2px orchid;
    `, block: '<div><progress value="49" max="100"></progress></div>'
        }, buttonTest: {
            style: `
      position: absolute;
      margin-top: -315.552px;
      margin-left: 15.9099rem;
      border: solid 2px turquoise;
    `, block: '<div><button type="button"></button></div>'
        }
    };

    function ys(e) {
        if (!e) throw new Error("No element");
        const n = document.createElement("template");
        n.innerHTML = e.block.trim();
        const t = n.content.firstChild;
        return t.style.cssText = e.style, t.outerHTML
    }

    async function xs() {
        return xt({action: vs})
    }

    async function vs(e, n) {
        const t = [];
        e.style.width = "700px", e.style.height = "600px";
        const i = n.document, {head: r, body: a} = i, o = Object.values(bs).map(ys).join(""),
            s = i.createElement("style");
        s.textContent = `
    caption {
      border: solid 2px darkred;
      font-size: 20.99px;
      margin-left: 20.8px;
    }
  `, r.appendChild(s), a.innerHTML = o;
        const f = Array.from(a.children);
        for (const l of f) {
            const {bottom: c, top: _, left: h, right: u, width: d, height: p, x: g, y: b} = l.getBoundingClientRect();
            t.push({bottom: c, top: _, left: h, right: u, width: d, height: p, x: g, y: b})
        }
        return t
    }

    function Es() {
        return window.screen.colorDepth
    }

    function Ss() {
        for (const e of ["srgb", "p3", "rec2020"]) if (ie("color-gamut", e)) return e;
        return null
    }

    function As() {
        const e = ["srgb", "p3", "rec2020"], n = {};
        return S(window, "matchMedia") ? e.forEach(t => {
            n[t] = window.matchMedia(`(color-gamut: ${t})`).matches
        }) : e.forEach(t => {
            n[t] = !1
        }), n
    }

    function Ts() {
        const e = document.createElement("div");
        document.body.appendChild(e);
        const n = window.getComputedStyle(e), t = [];
        for (let i = 0; i < n.length; i++) t.push(n[i]);
        for (const i in n) !t.includes(i) && Number.isNaN(Number(i)) && t.push(i);
        return document.body.removeChild(e), t.sort()
    }

    function ks() {
        const e = ie("prefers-contrast");
        return e("no-preference") ? tt.None : e("high") || e("more") ? tt.More : e("low") || e("less") ? tt.Less : e("forced") ? tt.ForcedColors : null
    }

    function Rs() {
        try {
            document.cookie = "cookietest=1; SameSite=Strict;";
            const e = document.cookie.indexOf("cookietest=") !== -1;
            return document.cookie = "cookietest=1; SameSite=Strict; expires=Thu, 01-Jan-1970 00:00:01 GMT", e
        } catch {
            return !1
        }
    }

    const Is = {
        "accent-color": ["initial"],
        "anchor-name": ["--tooltip"],
        "border-end-end-radius": ["initial"],
        color: ["light-dark"],
        fill: ["context-fill", "context-stroke"],
        float: ["inline-start", "inline-end"],
        "font-size": ["1cap", "1rcap"],
        "grid-template-rows": ["subgrid"],
        "paint-order": ["normal", "stroke", "markers", "fill", "revert"],
        stroke: ["context-fill", "context-stroke"],
        "text-decoration": ["spelling-error"],
        "text-wrap": ["pretty"],
        "transform-box": ["stroke-box"]
    };

    function Ms() {
        const e = document.createElement("div");
        document.body.appendChild(e);
        const n = {};
        for (const [t, i] of Object.entries(Is)) {
            n[t] = {};
            for (const r of i) e.style[t] = r, n[t][r] = e.style[t] === r
        }
        return document.body.removeChild(e), n
    }

    function Os() {
        return window.devicePixelRatio
    }

    async function Ds() {
        if (!navigator.requestMediaKeySystemAccess) return {supported: !1};
        const e = ["com.widevine.alpha", "com.microsoft.playready", "com.apple.fps.1_0", "org.w3.clearkey"], n = [{
            initDataTypes: ["cenc"],
            audioCapabilities: [{contentType: 'audio/mp4; codecs="mp4a.40.2"'}],
            videoCapabilities: [{contentType: 'video/mp4; codecs="avc1.42E01E"'}]
        }];
        try {
            const t = await Promise.all(e.map(i => navigator.requestMediaKeySystemAccess(i, n).then(() => ({[i]: !0})).catch(() => ({[i]: !1}))));
            return {supported: !0, systems: Object.assign({}, ...t)}
        } catch {
            return {supported: !1}
        }
    }

    function Cs() {
        return ["FileReader", "FileList", "File", "FileSystemDirectoryHandle", "FileSystemFileHandle", "FileSystemHandle", "FileSystemWritableFileStream", "showOpenFilePicker", "showSaveFilePicker", "webkitRequestFileSystem", "webkitResolveLocalFileSystemURL"].filter(e => S(window, e))
    }

    function Ns() {
        const {mimeTypes: e} = navigator;
        let n = !1;
        try {
            n = new ActiveXObject("ShockwaveFlash.ShockwaveFlash")
        } catch {
            e && e["application/x-shockwave-flash"] && e["application/x-shockwave-flash"].enabledPlugin && (n = !0)
        }
        return n
    }

    const Fs = "mmMwWLliI0fiflO&1", dn = {
        default: [],
        apple: [{font: "-apple-system-body"}],
        serif: [{fontFamily: "serif"}],
        sans: [{fontFamily: "sans-serif"}],
        mono: [{fontFamily: "monospace"}],
        min: [{fontSize: "1px"}],
        system: [{fontFamily: "system-ui"}]
    };

    function Ps() {
        return Ls((e, n) => {
            const t = {}, i = {};
            for (const r of Object.keys(dn)) {
                const [a = {}, o = Fs] = dn[r], s = e.createElement("span");
                s.textContent = o, s.style.whiteSpace = "nowrap";
                for (const f of Object.keys(a)) {
                    const l = a[f];
                    l && (s.style[f] = l)
                }
                t[r] = s, n.append(e.createElement("br"), s)
            }
            for (const r of Object.keys(dn)) i[r] = t[r].getBoundingClientRect().width;
            return i
        })
    }

    function Ls(e, n = 4e3) {
        return xt({
            action: (t, i) => {
                const r = i.document, a = r.body, o = a.style;
                o.width = `${n}px`, o.webkitTextSizeAdjust = "none", o.textSizeAdjust = "none", ps() ? a.style.zoom = `${1 / i.devicePixelRatio}` : vt() && (a.style.zoom = "reset");
                const s = r.createElement("div");
                return s.textContent = [...Array(n / 20 << 0)].map(() => "word").join(" "), a.appendChild(s), e(r, a)
            },
            initialHtml: '<!doctype html><html><head><meta name="viewport" content="width=device-width, initial-scale=1">'
        })
    }

    function Us() {
        const e = ["Consolas", "Windows sans-serif", "Windows serif", "mix Consolas"],
            n = document.createElement("span");
        n.style.position = "absolute", n.style.left = "-9999px", n.style.fontSize = "12px", n.style.lineHeight = "normal", n.textContent = "abcdefghijklmnopqrstuvwxyz0123456789", document.body.appendChild(n);
        const t = e.map(i => (n.style.fontFamily = i, {
            font: i,
            offsetWidth: n.offsetWidth,
            offsetHeight: n.offsetHeight
        }));
        return document.body.removeChild(n), t
    }

    const zs = "48px", Bs = "mmmMMMmmmlllmmmLLL₹▁₺ꜽ�₸׆ẞॿmmmiiimmmIIImmmwwwmmmWWW",
        De = ["monospace", "sans-serif", "serif"],
        tr = ["ARNO PRO", "Agency FB", "Andale Mono", "Apple Braille", "Apple Chancery", "Apple Color Emoji", "Apple SD Gothic Neo", "Apple Symbols", "AppleGothic", "Arabic Typesetting", "Arial", "Arial Black", "Arial Hebrew", "Arial MT", "Arial Narrow", "Arial Rounded MT Bold", "Arial Unicode MS", "AvantGarde Bk BT", "BankGothic Md BT", "Batang", "Bitstream Vera Sans Mono", "Book Antiqua", "Bookman Old Style", "Calibri", "Cambria", "Cambria Math", "Century", "Century Gothic", "Century Schoolbook", "Clarendon", "Comic Sans", "Comic Sans MS", "Consolas", "Courier", "Courier New", "EUROSTILE", "Franklin Gothic", "Futura Bk BT", "Futura Md BT", "GOTHAM", "Garamond", "Geneva", "Georgia", "Gill Sans", "HELV", "Haettenschweiler", "Helvetica", "Helvetica Neue", "Humanst521 BT", "Impact", "LUCIDA GRANDE", "Leelawadee", "Letter Gothic", "Levenim MT", "Lucida Bright", "Lucida Calligraphy", "Lucida Console", "Lucida Fax", "Lucida Grande", "Lucida Handwriting", "Lucida Sans", "Lucida Sans Typewriter", "Lucida Sans Unicode", "MS Gothic", "MS Mincho", "MS Outlook", "MS PGothic", "MS Reference Sans Serif", "MS Reference Specialty", "MS Sans Serif", "MS Serif", "MS UI Gothic", "MT Extra", "MYRIAD", "MYRIAD PRO", "Marlett", "Meiryo UI", "Menlo", "Microsoft Himalaya", "Microsoft JhengHei", "Microsoft Sans Serif", "Microsoft Tai Le", "Microsoft Uighur", "Microsoft YaHei", "Microsoft Yi Baiti", "Minion Pro", "Monaco", "Monotype Corsiva", "PMingLiU", "Palatino", "Palatino Linotype", "Pristina", "SCRIPTINA", "Segoe Print", "Segoe Script", "Segoe UI", "Segoe UI Light", "Segoe UI Semibold", "Segoe UI Symbol", "Serifa", "SimHei", "Small Fonts", "Staccato222 BT", "TRAJAN PRO", "Tahoma", "Times", "Times New Roman", "Times New Roman PS", "Trebuchet MS", "Univers CE 55 Medium", "Verdana", "Vrinda", "Webdings", "Wingdings", "Wingdings 2", "Wingdings 3", "ZWAdobeF", "sans-serif-thin"];

    function Hs(e = tr) {
        return xt({action: Zs}, e)
    }

    async function Zs(e, {document: n}, t) {
        const i = n.body;
        i.style.fontSize = zs;
        const r = n.createElement("div");
        r.style.setProperty("visibility", "hidden", "important");
        const a = {}, o = {}, s = d => {
            const p = n.createElement("span"), {style: g} = p;
            return g.position = "absolute", g.top = "0", g.left = "0", g.fontFamily = d, p.textContent = Bs, r.appendChild(p), p
        }, f = (d, p) => s(`'${d}',${p}`), l = () => De.map(s), c = () => {
            const d = {};
            for (const p of t) d[p] = De.map(g => f(p, g));
            return d
        }, _ = d => De.some((p, g) => d[g].offsetWidth !== a[p] || d[g].offsetHeight !== o[p]), h = l(), u = c();
        i.appendChild(r), await et(0);
        for (let d = 0; d < De.length; d++) a[De[d]] = h[d].offsetWidth, o[De[d]] = h[d].offsetHeight;
        return tr.filter(d => _(u[d]))
    }

    function Vs() {
        const e = ie("forced-colors");
        return e("active") ? !0 : e("none") ? !1 : null
    }

    function Gs() {
        return navigator.globalPrivacyControl ?? null
    }

    const $s = ["1.0", "1.1", "1.2", "1.3", "1.4", "2.0", "2.1", "2.2", "2.3"], Xs = [{
        videoCapabilities: [{
            contentType: 'video/webm; codecs="vp09.00.10.08"',
            robustness: "SW_SECURE_DECODE"
        }]
    }];

    async function Ws() {
        try {
            const e = await (await navigator.requestMediaKeySystemAccess("com.widevine.alpha", Xs)).createMediaKeys();
            if (!("getStatusForPolicy" in e)) return "HDCP Policy Check API is not available";
            const n = {}, t = [];
            for (const i of $s) {
                const r = e.getStatusForPolicy({minHdcpVersion: i}).then(a => {
                    n[i] = a !== "usable" ? a : "available"
                });
                t.push(r)
            }
            return await Promise.all(t), n
        } catch (e) {
            return console.log(e), null
        }
    }

    function js() {
        const e = ie("dynamic-range");
        return e("high") ? !0 : e("standard") ? !1 : null
    }

    function Ks() {
        if (er() || gs()) return null;
        try {
            return !!window.indexedDB
        } catch {
            return !0
        }
    }

    function Ys() {
        return B.isUndefined(Intl) ? null : {
            dateTimeOptions: nt(Intl.DateTimeFormat),
            numberFormatOptions: nt(Intl.NumberFormat),
            collatorOptions: nt(Intl.Collator),
            pluralRulesOptions: nt(Intl.PluralRules),
            relativeTimeFormatOptions: nt(Intl.RelativeTimeFormat)
        }
    }

    function nt(e) {
        return new e().resolvedOptions()
    }

    function qs() {
        const e = ie("inverted-colors");
        return e("inverted") ? !0 : e("none") ? !1 : null
    }

    function Js() {
        return navigator.javaEnabled()
    }

    function Qs() {
        try {
            return !!window.localStorage
        } catch {
            return !0
        }
    }

    function el() {
        const e = () => 0, n = Math.acos || e, t = Math.acosh || e, i = Math.asin || e, r = Math.asinh || e,
            a = Math.atanh || e, o = Math.atan || e, s = Math.sin || e, f = Math.sinh || e, l = Math.cos || e,
            c = Math.cosh || e, _ = Math.tan || e, h = Math.tanh || e, u = Math.exp || e, d = Math.expm1 || e,
            p = Math.log1p || e, g = w => Math.PI ** w, b = w => Math.log(w + Math.sqrt(w * w - 1)),
            v = w => Math.log(w + Math.sqrt(w * w + 1)), x = w => Math.log((1 + w) / (1 - w)) / 2,
            m = w => Math.exp(w) - 1 / Math.exp(w) / 2, k = w => (Math.exp(w) + 1 / Math.exp(w)) / 2,
            C = w => Math.exp(w) - 1, y = w => (Math.exp(2 * w) - 1) / (Math.exp(2 * w) + 1), I = w => Math.log(1 + w);
        return {
            acos: n(.12312423423423424),
            acosh: t(1e308),
            acoshPf: b(1e154),
            asin: i(.12312423423423424),
            asinh: r(1),
            asinhPf: v(1),
            atanh: a(.5),
            atanhPf: x(.5),
            atan: o(.5),
            sin: s(-1e300),
            sinh: f(1),
            sinhPf: m(1),
            cos: l(10.000000000123),
            cosh: c(1),
            coshPf: k(1),
            tan: _(-1e300),
            tanh: h(1),
            tanhPf: y(1),
            exp: u(1),
            expm1: d(1),
            expm1Pf: C(1),
            log1p: p(10),
            log1pPf: I(10),
            powPI: g(-100)
        }
    }

    function tl() {
        if (!(navigator.mediaDevices && navigator.mediaDevices.getSupportedConstraints)) return console.warn("MediaDevices API is not supported"), null;
        const e = {}, n = navigator.mediaDevices.getSupportedConstraints();
        for (const t in n) e[t] = n[t];
        return e
    }

    async function nl() {
        if (!S(navigator, "mediaCapabilities")) return [];
        const e = [{
            type: "file",
            video: {
                contentType: 'video/mp4; codecs="avc1.42E01E"',
                width: 1920,
                height: 1080,
                bitrate: 2646242,
                framerate: 30
            }
        }, {
            type: "file",
            video: {contentType: 'video/webm; codecs="vp9"', width: 1920, height: 1080, bitrate: 2646242, framerate: 30}
        }, {
            type: "file",
            video: {contentType: 'video/ogg; codecs="theora"', width: 1280, height: 720, bitrate: 15e5, framerate: 30}
        }, {
            type: "media-source",
            video: {
                contentType: 'video/mp4; codecs="avc1.42E01E"',
                width: 1920,
                height: 1080,
                bitrate: 2646242,
                framerate: 30
            }
        }, {
            type: "media-source",
            video: {contentType: 'video/webm; codecs="vp9"', width: 1920, height: 1080, bitrate: 2646242, framerate: 30}
        }, {
            type: "media-source",
            video: {contentType: 'video/ogg; codecs="theora"', width: 1280, height: 720, bitrate: 15e5, framerate: 30}
        }];
        return await Promise.all(e.map(async n => {
            try {
                const t = await navigator.mediaCapabilities.decodingInfo(n);
                return {
                    contentType: n.video.contentType,
                    powerEfficient: t.powerEfficient,
                    smooth: t.smooth,
                    supported: t.supported,
                    keySystemAccess: t.keySystemAccess
                }
            } catch {
                return {
                    contentType: n.video.contentType,
                    powerEfficient: !1,
                    smooth: !1,
                    supported: !1,
                    keySystemAccess: null
                }
            }
        }))
    }

    function il() {
        if (!ie("min-monochrome", "0")) return null;
        for (let e = 0; e <= 100; ++e) if (ie("max-monochrome", e.toString())) return e;
        throw new Error("Too high value")
    }

    async function rl() {
        const e = {}, {plugins: n, mimeTypes: t, userAgentData: i} = navigator,
            r = ["userAgent", "appName", "appVersion", "appCodeName", "deviceMemory", "hardwareConcurrency", "platform", "product", "language", "languages", "oscpu", "cpuClass", "productSub", "vendorSub", "vendor", "maxTouchPoints", "doNotTrack", "pdfViewerEnabled", "cookieEnabled", "onLine", "webdriver", "userAgentData"],
            a = ["architecture", "bitness", "brands", "mobile", "model", "platform", "platformVersion", "uaFullVersion", "wow64", "fullVersionList"];
        for (const o of r) B.isUndefined(navigator[o]) || (e[o] = navigator[o]);
        e.mimeTypes = t ? {} : null;
        for (const o of t) e.mimeTypes[o.type] = {
            description: o.description,
            suffixes: o.suffixes,
            enabledPlugin: o.enabledPlugin.name
        };
        e.plugins = n ? [] : null;
        for (let o = 0; o < n?.length; ++o) {
            const s = n[o];
            if (!s) continue;
            const f = [];
            for (let l = 0; l < s.length; ++l) {
                const c = s[l];
                f.push({type: c.type, suffixes: c.suffixes})
            }
            e.plugins.push({name: s.name, description: s.description, filename: s.filename, mimeTypes: f})
        }
        return e.highEntropyValues = await i?.getHighEntropyValues(a) ?? null, e
    }

    function al() {
        const e = [];
        for (const n in window.navigator) e.push(n);
        return e
    }

    async function ol() {
        return S(navigator, "connection")
    }

    function sl() {
        return !!window.openDatabase
    }

    function ll() {
        const e = ie("prefers-reduced-motion");
        return e("reduce") ? !0 : e("no-preference") ? !1 : null
    }

    function cl() {
        const e = ie("prefers-reduced-transparency");
        return e("reduce") ? !0 : e("no-preference") ? !1 : null
    }

    function fl() {
        return S(navigator, "scheduling") ? {isInputPending: navigator.scheduling.isInputPending ? navigator.scheduling.isInputPending() : null} : null
    }

    function Et(e) {
        return e === null ? null : Ko(e, 10)
    }

    function hn() {
        return [pe(Q(window.screen.availTop), null), pe(Q(window.screen.width) - Q(window.screen.availWidth) - pe(Q(window.screen.availLeft), 0), null), pe(Q(window.screen.height) - Q(window.screen.availHeight) - pe(Q(window.screen.availTop), 0), null), pe(Q(window.screen.availLeft), null)]
    }

    function _n(e) {
        for (let n = 0; n < 4; ++n) if (e[n]) return !1;
        return !0
    }

    let St = null, mn = null;

    async function ul() {
        dl();
        let e = hn();
        if (_n(e)) {
            if (St) return [...St];
            Yo() && (await qo(), e = hn())
        }
        return _n(e) || (St = e), e
    }

    function dl() {
        if (mn !== null) return;
        const e = 2500, n = () => {
            const t = hn();
            _n(t) ? mn = setTimeout(n, e) : (St = t, mn = null)
        };
        n()
    }

    async function hl() {
        if (vt() && un() && fn()) return null;
        const e = await ul();
        return [Et(e[0]), Et(e[1]), Et(e[2]), Et(e[3])]
    }

    function _l() {
        if (vt() && un() && fn()) return null;
        const e = t => pe(Ji(t), null), n = [e(window.screen.width), e(window.screen.height)];
        return n.sort().reverse(), n
    }

    function ml() {
        try {
            return !!window.sessionStorage
        } catch {
            return !0
        }
    }

    function gl() {
        if (S(window, "ActiveXObject")) try {
            return new window.ActiveXObject("AgControl.AgControl"), !0
        } catch {
            return !1
        }
        const e = navigator.mimeTypes["application/x-silverlight-2"];
        return !B.isUndefined(e) && !B.isNull(e.enabledPlugin)
    }

    async function pl() {
        return S(window, "speechSynthesis") ? new Promise(e => {
            let n = window.speechSynthesis.getVoices();
            n.length ? e(nr(n)) : window.speechSynthesis.onvoiceschanged = () => {
                n = window.speechSynthesis.getVoices(), e(nr(n))
            }
        }) : null
    }

    function nr(e) {
        return e.map(n => ({
            default: n.default,
            lang: n.lang,
            localService: n.localService,
            name: n.name,
            voiceURI: n.voiceURI
        }))
    }

    async function wl() {
        if (navigator.storage && navigator.storage.estimate) try {
            const e = await navigator.storage.estimate();
            return {quota: e.quota, usage: e.usage}
        } catch (e) {
            return console.error("Error when retrieving storage information: ", e), null
        }
        return console.warn("The storage API is not supported"), null
    }

    function bl() {
        return ["length", "name", "prototype", "for", "keyFor", "asyncIterator", "hasInstance", "isConcatSpreadable", "iterator", "match", "matchAll", "replace", "search", "species", "split", "toPrimitive", "toStringTag", "unscopables", "dispose"].filter(e => S(Symbol, e))
    }

    function yl() {
        const e = ["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui"],
            n = ["ActiveText", "ButtonFace", "ButtonText", "Canvas", "CanvasText", "Field", "FieldText", "GrayText", "Highlight", "HighlightText", "LinkText", "Mark", "MarkText", "VisitedText"],
            t = document.createElement("canvas"), i = t.getContext("2d");
        if (!i) return console.warn("Failed to get canvas context"), null;
        const r = n.map(o => (i.fillStyle = o, i.fillStyle)), a = e.map(o => (i.font = `12px ${o}`, i.font));
        return t.remove(), {colors: r, fonts: a}
    }

    function xl() {
        const e = window.Intl?.DateTimeFormat;
        if (e) {
            const i = new e().resolvedOptions().timeZone;
            if (i) return i
        }
        const n = new Date().getFullYear(),
            t = -Math.max(Q(new Date(n, 0, 1).getTimezoneOffset()), Q(new Date(n, 6, 1).getTimezoneOffset()));
        return `UTC${t >= 0 ? "+" : ""}${t}`
    }

    function vl() {
        let e = 0, n;
        navigator.maxTouchPoints !== void 0 && (e = Ji(navigator.maxTouchPoints));
        try {
            document.createEvent("TouchEvent"), n = !0
        } catch {
            n = !1
        }
        const t = S(window, "ontouchstart");
        return {maxTouchPoints: e, touchEvent: n, touchStart: t}
    }

    const El = ["chrome", "safari", "__crWeb", "__gCrWeb", "yandex", "__yb", "__ybro", "__firefox__", "__edgeTrackingPreventionStatistics", "webkit", "oprt", "samsungAr", "ucweb", "UCShellJava", "puffinDevice"];

    function Sl() {
        const e = [];
        for (const n of El) {
            const t = window[n];
            t && typeof t == "object" && e.push(n)
        }
        return e.sort()
    }

    function ir(e, n) {
        const t = e.getShaderPrecisionFormat(e[n], e.HIGH_FLOAT), i = e.getShaderPrecisionFormat(e[n], e.MEDIUM_FLOAT);
        if (!(t || i)) return null;
        let r = t;
        return t.precision || (r = i), [r.precision, r.rangeMin, r.rangeMax]
    }

    function Al(e) {
        const n = e.getShaderPrecisionFormat(e.FRAGMENT_SHADER, e.HIGH_FLOAT),
            t = e.getShaderPrecisionFormat(e.FRAGMENT_SHADER, e.HIGH_INT);
        if (!(n && t)) return null;
        const i = n.precision !== 0 ? "highp/" : "mediump/", r = t.rangeMax !== 0 ? "highp" : "lowp";
        return `${i}${r}`
    }

    function Tl(e) {
        const n = e.getExtension("EXT_texture_filter_anisotropic") || e.getExtension("WEBKIT_EXT_texture_filter_anisotropic") || e.getExtension("MOZ_EXT_texture_filter_anisotropic");
        if (!n) return null;
        let t = e.getParameter(n.MAX_TEXTURE_MAX_ANISOTROPY_EXT);
        return t === 0 && (t = 2), t
    }

    function gn(e, n) {
        const t = e.getParameter(e[n]);
        return t ? Object.values(t) : null
    }

    function rr(e, n) {
        const t = n.map(i => e.getParameter(e[i]));
        return t.some(i => i != null) ? t : null
    }

    const be = "n/a", kl = ["FRAGMENT_SHADER", "VERTEX_SHADER"],
        Rl = ["LOW_FLOAT", "MEDIUM_FLOAT", "HIGH_FLOAT", "LOW_INT", "MEDIUM_INT", "HIGH_INT"],
        Il = ["copyBufferSubData", "getBufferSubData", "blitFramebuffer", "framebufferTextureLayer", "getInternalformatParameter", "invalidateFramebuffer", "invalidateSubFramebuffer", "readBuffer", "renderbufferStorageMultisample", "texStorage2D", "texStorage3D", "texImage3D", "texSubImage3D", "copyTexSubImage3D", "compressedTexImage3D", "compressedTexSubImage3D", "getFragDataLocation", "uniform1ui", "uniform2ui", "uniform3ui", "uniform4ui", "uniform1uiv", "uniform2uiv", "uniform3uiv", "uniform4uiv", "uniformMatrix2x3fv", "uniformMatrix3x2fv", "uniformMatrix2x4fv", "uniformMatrix4x2fv", "uniformMatrix3x4fv", "uniformMatrix4x3fv", "vertexAttribI4i", "vertexAttribI4iv", "vertexAttribI4ui", "vertexAttribI4uiv", "vertexAttribIPointer", "vertexAttribDivisor", "drawArraysInstanced", "drawElementsInstanced", "drawRangeElements", "drawBuffers", "clearBufferiv", "clearBufferuiv", "clearBufferfv", "clearBufferfi", "createQuery", "deleteQuery", "isQuery", "beginQuery", "endQuery", "getQuery", "getQueryParameter", "createSampler", "deleteSampler", "isSampler", "bindSampler", "samplerParameteri", "samplerParameterf", "getSamplerParameter", "fenceSync", "isSync", "deleteSync", "clientWaitSync", "waitSync", "getSyncParameter", "createTransformFeedback", "deleteTransformFeedback", "isTransformFeedback", "bindTransformFeedback", "beginTransformFeedback", "endTransformFeedback", "transformFeedbackVaryings", "getTransformFeedbackVarying", "pauseTransformFeedback", "resumeTransformFeedback", "bindBufferBase", "bindBufferRange", "getIndexedParameter", "getUniformIndices", "getActiveUniforms", "getUniformBlockIndex", "getActiveUniformBlockParameter", "getActiveUniformBlockName", "uniformBlockBinding", "createVertexArray", "deleteVertexArray", "isVertexArray", "bindVertexArray"],
        ar = {
            vertexShader: ["MAX_VERTEX_ATTRIBS", "MAX_VERTEX_UNIFORM_VECTORS", "MAX_VERTEX_TEXTURE_IMAGE_UNITS", "MAX_VARYING_VECTORS", "VERTEX_BEST_FLOAT_PRECISION", "MAX_VERTEX_UNIFORM_COMPONENTS", "MAX_VERTEX_UNIFORM_BLOCKS", "MAX_VERTEX_OUTPUT_COMPONENTS", "MAX_VARYING_COMPONENTS"],
            transformFeedback: ["MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS", "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"],
            rasterizer: ["ALIASED_POINT_SIZE_RANGE", "ALIASED_LINE_WIDTH_RANGE"],
            fragmentShader: ["MAX_FRAGMENT_UNIFORM_VECTORS", "MAX_TEXTURE_IMAGE_UNITS", "FLOAT_INT_PRECISION", "FRAGMENT_BEST_FLOAT_PRECISION", "MAX_FRAGMENT_UNIFORM_COMPONENTS", "MAX_FRAGMENT_UNIFORM_BLOCKS", "MAX_FRAGMENT_INPUT_COMPONENTS", "MIN_PROGRAM_TEXEL_OFFSET", "MAX_PROGRAM_TEXEL_OFFSET"],
            framebuffer: ["MAX_DRAW_BUFFERS", "MAX_COLOR_ATTACHMENTS", "MAX_SAMPLES", "RGBA_BITS", "DEPTH_STENCIL_BITS", "MAX_RENDERBUFFER_SIZE", "MAX_VIEWPORT_DIMS"],
            textures: ["MAX_TEXTURE_SIZE", "MAX_CUBE_MAP_TEXTURE_SIZE", "MAX_COMBINED_TEXTURE_IMAGE_UNITS", "MAX_TEXTURE_MAX_ANISOTROPY_EXT", "MAX_3D_TEXTURE_SIZE", "MAX_ARRAY_TEXTURE_LAYERS", "MAX_TEXTURE_LOD_BIAS"],
            uniformBuffers: ["MAX_UNIFORM_BUFFER_BINDINGS", "MAX_UNIFORM_BLOCK_SIZE", "UNIFORM_BUFFER_OFFSET_ALIGNMENT", "MAX_COMBINED_UNIFORM_BLOCKS", "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"]
        },
        Ml = ["r8unorm", "r8snorm", "r8uint", "r8sint", "r16uint", "r16sint", "r16float", "rg8unorm", "rg8snorm", "rg8uint", "rg8sint", "r32uint", "r32sint", "r32float", "rg16uint", "rg16sint", "rg16float", "rgba8unorm", "rgba8unorm-srgb", "rgba8snorm", "rgba8uint", "rgba8sint", "bgra8unorm", "bgra8unorm-srgb", "rgb9e5ufloat", "rgb10a2unorm", "rg11b10ufloat", "rg32uint", "rg32sint", "rg32float", "rgba16uint", "rgba16sint", "rgba16float", "rgba32uint", "rgba32sint", "rgba32float", "stencil8", "depth16unorm", "depth24plus", "depth24plus-stencil8", "depth32float", "depth32float-stencil8", "bc1-rgba-unorm", "bc1-rgba-unorm-srgb", "bc2-rgba-unorm", "bc2-rgba-unorm-srgb", "bc3-rgba-unorm", "bc3-rgba-unorm-srgb", "bc4-r-unorm", "bc4-r-snorm", "bc5-rg-unorm", "bc5-rg-snorm", "bc6h-rgb-ufloat", "bc6h-rgb-float", "bc7-rgba-unorm", "bc7-rgba-unorm-srgb", "etc2-rgb8unorm", "etc2-rgb8unorm-srgb", "etc2-rgb8a1unorm", "etc2-rgb8a1unorm-srgb", "etc2-rgba8unorm", "etc2-rgba8unorm-srgb", "eac-r11unorm", "eac-r11snorm", "eac-rg11unorm", "eac-rg11snorm", "astc-4x4-unorm", "astc-4x4-unorm-srgb", "astc-5x4-unorm", "astc-5x4-unorm-srgb", "astc-5x5-unorm", "astc-5x5-unorm-srgb", "astc-6x5-unorm", "astc-6x5-unorm-srgb", "astc-6x6-unorm", "astc-6x6-unorm-srgb", "astc-8x5-unorm", "astc-8x5-unorm-srgb", "astc-8x6-unorm", "astc-8x6-unorm-srgb", "astc-8x8-unorm", "astc-8x8-unorm-srgb", "astc-10x5-unorm", "astc-10x5-unorm-srgb", "astc-10x6-unorm", "astc-10x6-unorm-srgb", "astc-10x8-unorm", "astc-10x8-unorm-srgb", "astc-10x10-unorm", "astc-10x10-unorm-srgb", "astc-12x10-unorm", "astc-12x10-unorm-srgb", "astc-12x12-unorm", "astc-12x12-unorm-srgb"],
        Ol = `
	precision mediump float;
	attribute vec2 vertPosition;
	attribute vec3 vertColor;
	varying vec3 fragColor;
	void main() {
	  fragColor = vertColor;
	  gl_Position = vec4(vertPosition, 0.0, 1.0);
	}
`, Dl = `
	precision mediump float;
	varying vec3 fragColor;
	void main() {
		gl_FragColor = vec4(fragColor, 1.0);
	}
`;

    function Cl(e) {
        const n = [], t = ["webgl2", "experimental-webgl2", "webgl", "experimental-webgl", "moz-webgl"];
        for (const i of t) {
            let r = null;
            try {
                r = e.getContext(i)
            } catch {
            }
            r && n.push({context: r, contextName: i});
            const a = document.createElement("canvas");
            a.width = e.width, a.height = e.height, e.replaceWith(a), e = a
        }
        return n
    }

    function Nl(e) {
        const {context: n, contextName: t} = e || {};
        if (!n) return null;
        const i = n.getExtension("WEBGL_debug_renderer_info"), r = n.getParameter(n.VERSION) || be,
            a = n.getParameter(n.SHADING_LANGUAGE_VERSION) || be, o = n.getParameter(n.VENDOR) || be,
            s = n.getParameter(n.RENDERER) || be, f = i && n.getParameter(i.UNMASKED_VENDOR_WEBGL) || be,
            l = i && n.getParameter(i.UNMASKED_RENDERER_WEBGL) || be;
        return {
            contextName: t,
            version: r,
            shadingLanguageVersion: a,
            vendor: o,
            renderer: s,
            unmaskedVendor: f,
            unmaskedRenderer: l
        }
    }

    function Fl(e) {
        if (!e) return null;
        const n = {};
        if (window.WebGL2RenderingContext) {
            const a = [];
            for (const o of Il) e[o] && a.push(o);
            n.supportedFunctions = a.sort()
        }
        const t = e.getContextAttributes();
        t && (n.contextAttributes = t);
        for (const a in ar) {
            const o = {};
            for (const s of ar[a]) {
                let f = null;
                const l = {
                    ALIASED_LINE_WIDTH_RANGE: () => gn(e, s),
                    ALIASED_POINT_SIZE_RANGE: () => gn(e, s),
                    DEPTH_STENCIL_BITS: () => rr(e, ["DEPTH_BITS", "STENCIL_BITS"]),
                    FLOAT_INT_PRECISION: () => Al(e),
                    FRAGMENT_BEST_FLOAT_PRECISION: () => ir(e, "FRAGMENT_SHADER"),
                    MAX_TEXTURE_MAX_ANISOTROPY_EXT: () => Tl(e),
                    MAX_VIEWPORT_DIMS: () => gn(e, s),
                    RGBA_BITS: () => rr(e, ["RED_BITS", "GREEN_BITS", "BLUE_BITS", "ALPHA_BITS"]),
                    VERTEX_BEST_FLOAT_PRECISION: () => ir(e, "VERTEX_SHADER")
                };
                try {
                    l[s] ? f = l[s]() : f = e.getParameter(e[s])
                } catch {
                }
                o[s] = f ?? be
            }
            n[a] = o
        }
        const i = {};
        for (const a of kl) {
            i[a] = {};
            for (const o of Rl) {
                const s = e.getShaderPrecisionFormat(e[a], e[o]), f = s ? [s.rangeMin, s.rangeMax, s.precision] : [];
                i[a][o] = f.join(",")
            }
        }
        n.shaderPrecisions = i;
        const r = e.getSupportedExtensions();
        if (r) {
            const a = [];
            for (const o of r) a.push(o);
            n.extensions = a.sort()
        }
        return n
    }

    function Pl(e, n) {
        const {width: t, height: i} = e, r = new Uint8Array(t * i * 4);
        Ll(n), n.readPixels(0, 0, t, i, n.RGBA, n.UNSIGNED_BYTE, r);
        const a = on(r);
        return ln(a)
    }

    function Ll(e) {
        e.clear(e.COLOR_BUFFER_BIT | e.DEPTH_BUFFER_BIT);
        const n = e.createShader(e.VERTEX_SHADER), t = e.createShader(e.FRAGMENT_SHADER);
        if (e.shaderSource(n, Ol), e.shaderSource(t, Dl), e.compileShader(n), !e.getShaderParameter(n, e.COMPILE_STATUS)) {
            console.error("ERROR compiling vertex shader!", e.getShaderInfoLog(n));
            return
        }
        if (e.compileShader(t), !e.getShaderParameter(t, e.COMPILE_STATUS)) {
            console.error("ERROR compiling fragment shader!", e.getShaderInfoLog(t));
            return
        }
        const i = e.createProgram();
        if (e.attachShader(i, n), e.attachShader(i, t), e.linkProgram(i), !e.getProgramParameter(i, e.LINK_STATUS)) {
            console.error("ERROR linking program!", e.getProgramInfoLog(i));
            return
        }
        if (e.validateProgram(i), !e.getProgramParameter(i, e.VALIDATE_STATUS)) {
            console.error("ERROR validating program!", e.getProgramInfoLog(i));
            return
        }
        const r = [0, .5, 1, 1, 0, -.5, -.5, .7, 0, 1, .5, -.5, .1, 1, .6], a = e.createBuffer();
        e.bindBuffer(e.ARRAY_BUFFER, a), e.bufferData(e.ARRAY_BUFFER, new Float32Array(r), e.STATIC_DRAW);
        const o = e.getAttribLocation(i, "vertPosition"), s = e.getAttribLocation(i, "vertColor");
        e.vertexAttribPointer(o, 2, e.FLOAT, !1, 5 * Float32Array.BYTES_PER_ELEMENT, 0), e.vertexAttribPointer(s, 3, e.FLOAT, !1, 5 * Float32Array.BYTES_PER_ELEMENT, 2 * Float32Array.BYTES_PER_ELEMENT), e.enableVertexAttribArray(o), e.enableVertexAttribArray(s), e.useProgram(i), e.drawArrays(e.TRIANGLES, 0, 3)
    }

    function Ul() {
        const e = {webglImageHash: "", supportedWebGLContexts: []}, n = document.createElement("canvas");
        n.width = 256, n.height = 128;
        const t = Cl(n);
        if (!t.length) return null;
        const [i] = t;
        e.webglImageHash = Pl(n, i.context);
        for (const r of t) {
            const a = Nl(r), {
                contextAttributes: o = null,
                shaderPrecisions: s = null,
                supportedFunctions: f = null,
                extensions: l = null,
                vertexShader: c = null,
                transformFeedback: _ = null,
                rasterizer: h = null,
                fragmentShader: u = null,
                framebuffer: d = null,
                textures: p = null,
                uniformBuffers: g = null
            } = Fl(r.context) || {};
            e.supportedWebGLContexts.push({
                basics: a,
                contextAttributes: o,
                shaderPrecisions: s,
                vertexShader: c,
                transformFeedback: _,
                rasterizer: h,
                fragmentShader: u,
                framebuffer: d,
                textures: p,
                uniformBuffers: g,
                extensions: l,
                supportedFunctions: f
            })
        }
        return e
    }

    async function zl() {
        const e = {}, n = document.createElement("canvas"),
            t = !!n.transferControlToOffscreen && n.transferControlToOffscreen();
        try {
            navigator.gpu && (e.api = !0);
            const i = await navigator.gpu.requestAdapter();
            if (i) {
                e.adapter = !0;
                const r = await navigator.gpu.requestAdapter({compatibilityMode: !0});
                e.compat = !!r, await i.requestDevice() && (e.device = !0, t && (e.context = !!t.getContext("webgpu")))
            }
        } catch (i) {
            console.error(i)
        }
        try {
            const i = new OffscreenCanvas(300, 150).getContext("2d");
            e.offscreen = !0, e.twoD = !!i
        } catch (i) {
            console.error(i)
        }
        return e
    }

    async function Bl(e) {
        try {
            const n = await navigator.gpu.requestAdapter(e);
            if (!n) return null;
            const t = Array.from(n.features), {limits: i} = n, [r, a] = await Promise.all([n.requestDevice({requiredFeatures: t}), n.requestAdapterInfo()]),
                o = await Hl(r), s = {};
            for (const l in i) s[l] = i[l];
            const f = {};
            for (const l in a) f[l] = a[l];
            return {
                info: f,
                limits: s,
                features: t,
                textureFormatCapabilities: o,
                flags: {isCompatibilityMode: n.isCompatibilityMode, isFallbackAdapter: n.isFallbackAdapter}
            }
        } catch (n) {
            return  null
        }
    }

    async function Hl(e) {
        try {
            const n = [];
            for (const t of Ml) try {
                let i = 1, r = 1;
                if ((t.startsWith("bc") || t.startsWith("e")) && (i = 4, r = 4), t.startsWith("astc")) {
                    const o = t.match(/(\d+)x(\d+)/);
                    o && (i = parseInt(o[1], 10), r = parseInt(o[2], 10))
                }
                const a = GPUTextureUsage;
                e.createTexture({
                    size: [i, r, 1],
                    format: t,
                    usage: a.SAMPLED | a.OUTPUT_ATTACHMENT | a.STORAGE | a.COPY_SRC | a.COPY_DST
                }), n.push(t)
            } catch {
            }
            return n
        } catch (n) {
            return console.error(n), null
        }
    }

    const Zl = {
        fallback: {powerPreference: "low-power", forceFallbackAdapter: !0},
        highPerformance: {powerPreference: "high-performance"}
    };

    async function Vl() {
        try {
            const e = {statuses: null};
            if (e.statuses = await zl(), !e.statuses.adapter) return e;
            e.supportedAdapters = {};
            const n = [];
            for (const [t, i] of Object.entries(Zl)) {
                const r = Bl(i).then(a => {
                    e.supportedAdapters[t] = a
                });
                n.push(r)
            }
            return await Promise.all(n), e
        } catch (e) {
            return console.error(e), null
        }
    }

    function Gl() {
        return ["onwebkitanimationend", "onwebkitanimationiteration", "onwebkitanimationstart", "onwebkittransitionend", "onwebkitfullscreenchange", "onwebkitfullscreenerror", "webkitMatchesSelector", "webkitRequestFullScreen", "webkitRequestFullscreen"].filter(e => S(document.documentElement, e))
    }

    const $l = {
        navigator: rl,
        cookiesEnabled: Rs,
        sessionStorage: ml,
        localStorage: Qs,
        openDatabase: sl,
        indexedDB: Ks,
        activeX: Uo,
        silverlight: gl,
        flash: Ns,
        java: Js,
        batteryAPI: ss,
        bluetoothAPI: ls,
        networkAPI: ol,
        timezone: xl,
        architecture: zo,
        devicePixelRatio: Os,
        globalPrivacyControl: Gs,
        colorDepth: Es,
        colorGamut: Ss,
        hdr: js,
        hdcp: Ws,
        invertedColors: qs,
        forcedColors: Vs,
        monochromeDepth: il,
        contrastPreference: ks,
        reducedMotion: cl,
        reducedTransparency: ll,
        vendorFlavors: Sl,
        touchSupport: vl,
        scheduling: fl,
        baseLatency: os,
        screenResolution: _l,
        screenFrame: hl,
        intl: Ys,
        math: el,
        fontPreferences: Ps,
        fonts: Hs,
        audio: as,
        canvas: ws,
        clientRects: xs,
        speechSynthesisVoices: pl,
        webgl: Ul,
        webgpu: Vl,
        storageQuota: wl,
        mediaCapabilities: tl,
        computedStyleProperties: Ts,
        systemInfo: yl,
        drmSupport: Ds,
        fileAPIs: Cs,
        symbolProperties: bl,
        webkitAPIs: Gl,
        builtInObjects: fs,
        cssSupport: Ms,
        colorSpaceSupport: As,
        fontRendering: Us,
        navigatorProperties: al,
        mediaDecodingCapabilities: nl
    };

    async function Xl() {
        if (S(navigator, "getBattery")) {
            const e = await navigator.getBattery();
            return {
                charging: e.charging,
                chargingTime: e.chargingTime,
                dischargingTime: e.dischargingTime,
                level: e.level
            }
        }
        return null
    }

    async function Wl() {
        return await jl() || Kl()
    }

    function jl() {
        let e = !1;
        const n = new Worker(URL.createObjectURL(new Blob([`
          "use strict";
            onmessage = () => {
              postMessage({ isOpenBeat: true });
              debugger;
              postMessage({ isOpenBeat: false });
            };
          `], {type: "text/javascript"})));
        return new Promise(t => {
            let i;
            n.onmessage = r => {
                r.data.isOpenBeat ? i = setTimeout(() => {
                    e = !0, n.terminate(), t(e)
                }, 100) : (clearTimeout(i), e = !1, n.terminate(), t(e))
            }, n.postMessage({})
        })
    }

    function Kl() {
        const e = window.outerWidth - window.innerWidth > 160, n = window.outerHeight - window.innerHeight > 160;
        return e || n
    }

    const Yl = {enableHighAccuracy: !0, maximumAge: 0, timeout: 10 * 1e3};

    async function ql() {
        try {
            const e = {statuses: {api: !0}};
            if (!navigator.geolocation) return e.statuses.api = !1, e;
            const n = await navigator.permissions.query({name: "geolocation"});
            if (e.statuses.permission = n.state, n.state === "denied") return e;
            const t = await Jl();
            return Ql(e, t), e
        } catch (e) {
            return console.error(e), null
        }
    }

    async function Jl() {
        return new Promise(e => {
            const n = t => {
                e({success: !1, error: {code: t.code, message: t.message}})
            };
            navigator.geolocation.getCurrentPosition(e, n, Yl)
        })
    }

    function Ql(e, n) {
        ec(n) ? e.geolocationPosition = {
            timestamp: n.timestamp,
            latitude: n.coords.latitude,
            longitude: n.coords.longitude,
            accuracy: n.coords.accuracy,
            altitude: n.coords.altitude,
            altitudeAccuracy: n.coords.altitudeAccuracy,
            heading: n.coords.heading,
            speed: n.coords.speed
        } : tc(n) ? e.error = n.error : console.error("Unknown result type from getGeolocationData() :>>", n)
    }

    function ec(e) {
        return !!e.coords
    }

    function tc(e) {
        return !!e.error
    }

    function nc() {
        const e = [];
        for (const n in window) S(window, n) && e.push(n);
        return e
    }

    async function ic() {
        try {
            const e = await jo("https://ipgeo.myip.link/");
            return e ? Object.entries(e).reduce((n, [t, i]) => {
                if (!["isEu", "metroCode", "regionCode", "airport"].includes(t)) {
                    const r = t === "timezone" && typeof i == "object" && S(i, "name");
                    n[t] = r ? i.name : i
                }
                return n
            }, {}) : null
        } catch (e) {
            return console.error(e), null
        }
    }

    function rc() {
        const {performance: e} = window;
        return e && e.memory ? {
            jsHeapSizeLimit: e.memory.jsHeapSizeLimit,
            totalJSHeapSize: e.memory.totalJSHeapSize,
            usedJSHeapSize: e.memory.usedJSHeapSize
        } : (console.warn("The memory API is not supported"), null)
    }

    function ac() {
        if (S(navigator, "connection")) {
            const {connection: e} = navigator;
            return {
                type: e.type ?? null,
                effectiveType: e.effectiveType ?? null,
                downlink: e.downlink ?? null,
                downlinkMax: e.downlinkMax ?? null,
                rtt: e.rtt ?? null,
                saveData: e.saveData ?? null
            }
        }
        return null
    }

    function oc() {
        const {performance: {navigation: e, timing: n}} = window, t = performance.getEntriesByType("navigation")[0],
            i = performance.getEntriesByType("paint");
        return {
            commitLoadTime: n.responseStart,
            finishDocumentLoadTime: n.domContentLoadedEventEnd,
            finishLoadTime: n.loadEventEnd,
            firstPaintAfterLoadTime: i.length > 0 ? i[0].startTime : 0,
            firstPaintTime: i.length > 0 ? i[0].startTime + n.navigationStart : 0,
            navigationType: ["navigate", "reload", "back_forward", "prerender"][e.type],
            npnNegotiatedProtocol: t ? t.nextHopProtocol : "unknown",
            requestTime: n.requestStart,
            startLoadTime: n.fetchStart,
            wasAlternateProtocolAvailable: t ? t.alternateProtocolUsage === "used" : !1,
            wasFetchedViaSpdy: t ? t.nextHopProtocol.includes("h2") || t.nextHopProtocol.includes("h3") : !1,
            wasNpnNegotiated: t ? t.nextHopProtocol !== "http/1.1" : !1
        }
    }

    function sc() {
        const e = {};
        return ["colorDepth", "pixelDepth", "height", "width", "availHeight", "availWidth", "availTop", "availLeft", "windowSize"].forEach(n => {
            n === "windowSize" ? e.windowSize = lc() : (window.screen[n] || Number.isInteger(window.screen[n])) && (e[n] = window.screen[n])
        }), e
    }

    function lc() {
        return {
            width: document.body?.clientWidth || window.innerWidth,
            height: document.body?.clientHeight || window.innerHeight
        }
    }

    async function cc(e = {iceServer: "stun.l.google.com:19302"}) {
        return new Promise((n, t) => {
            const i = [], r = {iceServers: [{urls: `stun:${e.iceServer}`}]}, a = new RTCPeerConnection(r);
            a.onicecandidate = o => {
                if (o.candidate) {
                    const {candidate: s} = o.candidate, f = /candidate:\d+ \d+ udp \d+ (.+) \d+ typ (\w+)/.exec(s);
                    Array.isArray(f) && f.length && !i.includes(f[1]) && i.push(f[1])
                } else {
                    const s = {public: [], private: [], allRes: i, log: a.localDescription?.sdp || ""};
                    i.forEach(f => {
                        fc(f) ? s.private.push(f) : f.endsWith(".local") || s.public.push(f)
                    }), n(s), a.close()
                }
            }, a.onicecandidateerror = o => {
                t(o), a.close()
            }, a.createDataChannel(""), a.createOffer().then(o => a.setLocalDescription(o)).catch(t)
        })
    }

    function fc(e) {
        return [/^10\.\d{1,3}\.\d{1,3}\.\d{1,3}$/, /^172\.(1[6-9]|2[0-9]|3[0-1])\.\d{1,3}\.\d{1,3}$/, /^192\.168\.\d{1,3}\.\d{1,3}$/, /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/].some(n => n.test(e))
    }

    const uc = {
        globalObjests: nc,
        devToolsOpen: Wl,
        screen: sc,
        location: ic,
        geolocation: ql,
        memory: rc,
        performance: oc,
        networkInfo: ac,
        batteryInfo: Xl,
        webrtc: cc
    }, dc = 2e3;

    async function pn(e, n) {
        const t = {}, {exclude: i, timeout: r = dc} = n || {};
        for (const a of Object.keys(e)) try {
            if (!B.isFunc(e[a]) || i?.includes(a)) continue;
            const o = e[a], s = Date.now();
            let f;
            o.constructor.name === "AsyncFunction" ? f = await Promise.race([o(), new Promise((l, c) => setTimeout(() => c(new Error("Timeout")), r))]) : f = o(), typeof f?.then == "function" && (f = await f), t[a] = {
                value: f,
                duration: Date.now() - s
            }
        } catch (o) {
            o.message === "Timeout" ? t[a] = {error: or("TimeoutError", `Timeout exceeded by ${r} ms`)} : t[a] = {error: or("InternalError", o.message)}
        }
        return t
    }

    function or(e, n) {
        return e === "TimeoutError" ? {code: "TimeoutError", message: n || "Timeout exceeded"} : {
            code: "InternalError",
            message: `An unexpected error occurred while collecting parameter data.${n ? ` Error: ${n}` : ""}`
        }
    }

    class hc {
        loadTime = null;
        fingerprintHash = null;
        cache = null;

        async load(n) {
            try {
                const t = Date.now(), [i, r] = await Promise.all([pn($l, n), pn(uc, n)]), a = {...i, ...r},
                    o = Date.now() - t, s = Jo(i, ["duration"]), f = JSON.stringify(s);
                this.loadTime = o, this.cache = a, this.fingerprintHash = Bo.hash128(f)
            } catch (t) {
                console.error(t)
            }
        }

        get(n) {
            return n && S(this.cache, n) ? this.cache[n].error ?? this.cache[n].value : n && this.cache ? null : this.cache
        }
    }

    async function _c() {
        const e = "InstallTrigger" in window, n = /constructor/i.test(window.HTMLElement),
            t = !!window.safari && !!window.safari.pushNotification && window.safari.pushNotification.toString() === "[object SafariRemoteNotification]",
            i = !!window.chrome, r = !!(window.chrome?.webstore || window.chrome?.runtime),
            a = !!window.navigator.brave && window.navigator.brave.toString() === "[object Brave]" && (await window.navigator.brave.isBrave() || !1),
            o = !!(window.opr || window.opera);
        return [e, n, t, i, r, a, o]
    }

    function mc() {
        let e = !1, n = !1, t = !1;
        const i = window.document, {external: r, navigator: a} = window;
        pc.forEach(d => {
            window[d] && (e = !0)
        }), gc.forEach(d => {
            i[d] && (n = !0)
        }), Object.keys(i).forEach(d => {
            d.match(/\$[a-z]dc_/) && i[d].cache_ && (t = !0)
        });
        const o = !!(r && r.toString() && r.toString().includes("Sequentum")),
            s = !!(i.documentElement.getAttribute("selenium") || i.documentElement.getAttribute("webdriver") || i.documentElement.getAttribute("driver")),
            f = !!a.webdriver, l = !Function.prototype.bind, c = !a.onLine, _ = (() => {
                let d = "";
                try {
                    new WebSocket("itsgonnafail")
                } catch (p) {
                    d = p.message
                }
                return !!/SyntaxError: DOM Exception 12/.test(d)
            })(), h = (() => {
                let d;
                try {
                    null[0]()
                } catch (p) {
                    d = p
                }
                return !!d && d.stack?.toString()?.includes("phantom")
            })(), u = (() => {
                let d = 0, p = "", g = "", b = 0;
                const v = () => {
                    try {
                        d++, v()
                    } catch (x) {
                        p = x.message, g = x.name, b = x.stack.toString().length
                    }
                };
                return v(), g === "RangeError" && p === "Maximum call stack size exceeded." && b > 20 * d
            })();
        return [e, t, n, l, c, h, u, _, s, o, f]
    }

    const gc = ["__driver_evaluate", "__driver_unwrapped", "__fxdriver_evaluate", "__fxdriver_unwrapped", "__selenium_evaluate", "__selenium_unwrapped", "__webdriver_evaluate", "__webdriver_script_fn", "__webdriver_script_func", "__webdriver_script_function", "__webdriver_unwrapped"],
        pc = ["Buffer", "_Selenium_IDE_Recorder", "__nightmare", "_phantom", "_selenium", "callPhantom", "callSelenium", "domAutomation", "domAutomationController", "emit", "fmget_targets", "phantom", "spawn", "webdriver"];

    function wc() {
        const {screen: e, innerWidth: n} = window;
        return [matchMedia(`(device-width: ${e.width}px) and (device-height: ${e.height}px)`).matches, matchMedia(`(min-width: ${n - 1}px)`).matches]
    }

    async function bc() {
        const e = await navigator.permissions?.query({name: "notifications"}), n = Notification?.permission ?? null,
            t = e?.state ?? null;
        return [n, t]
    }

    function yc() {
        const e = Object.getPrototypeOf(navigator);
        return !Object.keys(e).every(t => {
            const i = Object.getOwnPropertyDescriptor(e, t);
            return i?.get ? /\[native code\]/.test(i.get.toString()) : !0
        })
    }

    function xc() {
        return xt({
            action: async (e, {document: n}) => {
                const t = n.createElement("iframe");
                t.srcdoc = "blank page", n.body.appendChild(t);
                const i = J.isUndefined(t.contentWindow.chrome);
                return t.remove(), !(/Chrome/.test(navigator.userAgent) && i)
            }
        })
    }

    const vc = Object.fromEntries([_c, mc, wc, bc, yc, xc].map((e, n) => [`${n}`, e]));

    async function Ec(e) {
        try {
            const n = new hc;
            await n.load(e);
            const t = n.get(), i = Tc(t);
            return {fingerprintHash: n.fingerprintHash, data: i}
        } catch (n) {
            return console.error(n), null
        }
    }

    async function Sc(e) {
        const n = Lo() ? "http://localhost:3000/api/fp" : "https://api.mixvisit.com/api/fp",
            t = await Po(n, {method: "POST", headers: {"Content-Type": "application/octet-stream"}, body: e});
        return kc(t)
    }

    async function Ac() {
        return await pn(vc)
    }

    function Tc(e) {
        return Rc(e) ? e : (console.error("MixVisit Lite data validation failed:", e), null)
    }

    function kc(e) {
        return Ic(e) ? e.success ? e : (console.error("API response is not successful:", e.error), null) : (console.error("Structure inconsistency in api responses:", e), null)
    }

    function Rc(e) {
        return e && J.isObject(e) && Object.values(e).length && Object.values(e).every(n => n && J.isObject(n) && (Je(n, "value") || Je(n, "error")))
    }

    function Ic(e) {
        return e && J.isObject(e) && (Je(e, "success") || Je(e, "error"))
    }

    class sr {
        loadTime = null;
        fingerprintHash = null;
        cache = null;

        async load(n) {
            const t = Date.now(), i = await Ec(n), r = kt(i?.data), a = await Ac(), o = kt(a),
                s = Fo(JSON.stringify({mixvisit: r, dataForChecks: o})), f = await Sc(s), l = kt(f?.data);
            l && r && J.isObject(l) && J.isObject(r) && (this.fingerprintHash = l.fingerprintHash, this.cache = {
                clientData: r,
                detected: l.detected,
                headers: l.headers,
                verification: l.verification
            });
            const c = Date.now();
            this.loadTime = c - t
        }

        get(n) {
            return n && this.cache.clientData && Je(this.cache.clientData, n) ? this.cache.clientData[n].error ?? this.cache.clientData[n].value : n && this.cache ? null : this.cache
        }
    }

    fe.MixVisitPro = sr, fe.default = sr, Object.defineProperties(fe, {
        __esModule: {value: !0},
        [Symbol.toStringTag]: {value: "Module"}
    })
});