@waku/sds 0.0.1

package/bundle/index.js

@@ -0,0 +1,998 @@
+/* Generated by the Nim Compiler v2.2.0 */
+var excHandler = 0;
+var NTI134217745 = {
+    size: 0,
+    kind: 17,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI134217749 = {
+    size: 0,
+    kind: 17,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI134217751 = {
+    size: 0,
+    kind: 17,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI134217743 = {
+    size: 0,
+    kind: 17,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI33555167 = {
+    size: 0,
+    kind: 17,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI33555175 = {
+    size: 0,
+    kind: 22,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI33554449 = {
+    size: 0,
+    kind: 28,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI33554450 = {
+    size: 0,
+    kind: 29,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI33555174 = {
+    size: 0,
+    kind: 22,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI33555171 = {
+    size: 0,
+    kind: 17,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI33555172 = {
+    size: 0,
+    kind: 17,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI134217741 = {
+    size: 0,
+    kind: 17,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NTI134217742 = {
+    size: 0,
+    kind: 17,
+    base: null,
+    node: null,
+    finalizer: null
+};
+var NNI134217742 = {
+    kind: 2,
+    len: 0,
+    offset: 0,
+    typ: null,
+    name: null,
+    sons: []
+};
+NTI134217742.node = NNI134217742;
+var NNI134217741 = {
+    kind: 2,
+    len: 0,
+    offset: 0,
+    typ: null,
+    name: null,
+    sons: []
+};
+NTI134217741.node = NNI134217741;
+var NNI33555172 = {
+    kind: 2,
+    len: 0,
+    offset: 0,
+    typ: null,
+    name: null,
+    sons: []
+};
+NTI33555172.node = NNI33555172;
+NTI33555174.base = NTI33555171;
+NTI33555175.base = NTI33555171;
+var NNI33555171 = {
+    kind: 2,
+    len: 5,
+    offset: 0,
+    typ: null,
+    name: null,
+    sons: [
+        {
+            kind: 1,
+            offset: "parent",
+            len: 0,
+            typ: NTI33555174,
+            name: "parent",
+            sons: null
+        },
+        {
+            kind: 1,
+            offset: "name",
+            len: 0,
+            typ: NTI33554450,
+            name: "name",
+            sons: null
+        },
+        {
+            kind: 1,
+            offset: "message",
+            len: 0,
+            typ: NTI33554449,
+            name: "msg",
+            sons: null
+        },
+        {
+            kind: 1,
+            offset: "trace",
+            len: 0,
+            typ: NTI33554449,
+            name: "trace",
+            sons: null
+        },
+        { kind: 1, offset: "up", len: 0, typ: NTI33555175, name: "up", sons: null }
+    ]
+};
+NTI33555171.node = NNI33555171;
+var NNI33555167 = {
+    kind: 2,
+    len: 0,
+    offset: 0,
+    typ: null,
+    name: null,
+    sons: []
+};
+NTI33555167.node = NNI33555167;
+NTI33555171.base = NTI33555167;
+NTI33555172.base = NTI33555171;
+NTI134217741.base = NTI33555172;
+NTI134217742.base = NTI134217741;
+var NNI134217743 = {
+    kind: 2,
+    len: 0,
+    offset: 0,
+    typ: null,
+    name: null,
+    sons: []
+};
+NTI134217743.node = NNI134217743;
+NTI134217743.base = NTI134217741;
+var NNI134217751 = {
+    kind: 2,
+    len: 0,
+    offset: 0,
+    typ: null,
+    name: null,
+    sons: []
+};
+NTI134217751.node = NNI134217751;
+NTI134217751.base = NTI33555172;
+var NNI134217749 = {
+    kind: 2,
+    len: 0,
+    offset: 0,
+    typ: null,
+    name: null,
+    sons: []
+};
+NTI134217749.node = NNI134217749;
+NTI134217749.base = NTI33555172;
+var NNI134217745 = {
+    kind: 2,
+    len: 0,
+    offset: 0,
+    typ: null,
+    name: null,
+    sons: []
+};
+NTI134217745.node = NNI134217745;
+NTI134217745.base = NTI33555172;
+function toJSStr(s_p0) {
+    var result_33556911 = null;
+    var res_33556965 = newSeq__system_u2508(s_p0.length);
+    var i_33556966 = 0;
+    var j_33556967 = 0;
+    {
+        Label2: while (true) {
+            if (!(i_33556966 < s_p0.length))
+                break Label2;
+            var c_33556968 = s_p0[i_33556966];
+            if (c_33556968 < 128) {
+                res_33556965[j_33556967] = String.fromCharCode(c_33556968);
+                i_33556966 += 1;
+            }
+            else {
+                var helper_33556994 = newSeq__system_u2508(0);
+                Label3: {
+                    while (true) {
+                        var code_33556995 = c_33556968.toString(16);
+                        if ((code_33556995 == null ? 0 : code_33556995.length) == 1) {
+                            helper_33556994.push("%0");
+                        }
+                        else {
+                            helper_33556994.push("%");
+                        }
+                        helper_33556994.push(code_33556995);
+                        i_33556966 += 1;
+                        if (s_p0.length <= i_33556966 || s_p0[i_33556966] < 128) {
+                            break Label3;
+                        }
+                        c_33556968 = s_p0[i_33556966];
+                    }
+                }
+                ++excHandler;
+                try {
+                    res_33556965[j_33556967] = decodeURIComponent(helper_33556994.join(""));
+                    --excHandler;
+                }
+                catch (EXCEPTION) {
+                    --excHandler;
+                    res_33556965[j_33556967] = helper_33556994.join("");
+                }
+                finally {
+                }
+            }
+            j_33556967 += 1;
+        }
+    }
+    if (res_33556965.length < j_33556967) {
+        for (var i = res_33556965.length; i < j_33556967; ++i)
+            res_33556965.push(null);
+    }
+    else {
+        res_33556965.length = j_33556967;
+    }
+    result_33556911 = res_33556965.join("");
+    return result_33556911;
+}
+function raiseException(e_p0, ename_p1) {
+    e_p0.name = ename_p1;
+    if (excHandler == 0) {
+        unhandledException(e_p0);
+    }
+    throw e_p0;
+}
+function modInt(a_p0, b_p1) {
+    if (b_p1 == 0)
+        raiseDivByZero();
+    if (b_p1 == -1 && a_p0 == 2147483647)
+        raiseOverflow();
+    return Math.trunc(a_p0 % b_p1);
+}
+function absInt(a_p0) {
+    var Temporary1;
+    var result_33557134 = 0;
+    if (a_p0 < 0) {
+        Temporary1 = a_p0 * -1;
+    }
+    else {
+        Temporary1 = a_p0;
+    }
+    result_33557134 = Temporary1;
+    return result_33557134;
+}
+function divInt(a_p0, b_p1) {
+    if (b_p1 == 0)
+        raiseDivByZero();
+    if (b_p1 == -1 && a_p0 == 2147483647)
+        raiseOverflow();
+    return Math.trunc(a_p0 / b_p1);
+}
+function mulInt(a_p0, b_p1) {
+    var result = a_p0 * b_p1;
+    checkOverflowInt(result);
+    return result;
+}
+function subInt(a_p0, b_p1) {
+    var result = a_p0 - b_p1;
+    checkOverflowInt(result);
+    return result;
+}
+function addInt(a_p0, b_p1) {
+    var result = a_p0 + b_p1;
+    checkOverflowInt(result);
+    return result;
+}
+function chckRange(i_p0, a_p1, b_p2) {
+    var result_33557358 = 0;
+    BeforeRet: {
+        if (a_p1 <= i_p0 && i_p0 <= b_p2) {
+            result_33557358 = i_p0;
+            break BeforeRet;
+        }
+        else {
+            raiseRangeError();
+        }
+    }
+    return result_33557358;
+}
+function setConstr() {
+    var result = {};
+    for (var i = 0; i < arguments.length; ++i) {
+        var x = arguments[i];
+        if (typeof x == "object") {
+            for (var j = x[0]; j <= x[1]; ++j) {
+                result[j] = true;
+            }
+        }
+        else {
+            result[x] = true;
+        }
+    }
+    return result;
+}
+var ConstSet1 = setConstr(17, 16, 4, 18, 27, 19, 23, 22, 21);
+function nimCopy(dest_p0, src_p1, ti_p2) {
+    var result_33557318 = null;
+    switch (ti_p2.kind) {
+        case 21:
+        case 22:
+        case 23:
+        case 5:
+            if (!isFatPointer__system_u2866(ti_p2)) {
+                result_33557318 = src_p1;
+            }
+            else {
+                result_33557318 = [src_p1[0], src_p1[1]];
+            }
+            break;
+        case 19:
+            if (dest_p0 === null || dest_p0 === undefined) {
+                dest_p0 = {};
+            }
+            else {
+                for (var key in dest_p0) {
+                    delete dest_p0[key];
+                }
+            }
+            for (var key in src_p1) {
+                dest_p0[key] = src_p1[key];
+            }
+            result_33557318 = dest_p0;
+            break;
+        case 18:
+        case 17:
+            if (!(ti_p2.base == null)) {
+                result_33557318 = nimCopy(dest_p0, src_p1, ti_p2.base);
+            }
+            else {
+                if (ti_p2.kind == 17) {
+                    result_33557318 =
+                        dest_p0 === null || dest_p0 === undefined
+                            ? { m_type: ti_p2 }
+                            : dest_p0;
+                }
+                else {
+                    result_33557318 =
+                        dest_p0 === null || dest_p0 === undefined ? {} : dest_p0;
+                }
+            }
+            nimCopyAux(result_33557318, src_p1, ti_p2.node);
+            break;
+        case 4:
+        case 16:
+            if (ArrayBuffer.isView(src_p1)) {
+                if (dest_p0 === null ||
+                    dest_p0 === undefined ||
+                    dest_p0.length != src_p1.length) {
+                    dest_p0 = new src_p1.constructor(src_p1);
+                }
+                else {
+                    dest_p0.set(src_p1, 0);
+                }
+                result_33557318 = dest_p0;
+            }
+            else {
+                if (src_p1 === null) {
+                    result_33557318 = null;
+                }
+                else {
+                    if (dest_p0 === null ||
+                        dest_p0 === undefined ||
+                        dest_p0.length != src_p1.length) {
+                        dest_p0 = new Array(src_p1.length);
+                    }
+                    result_33557318 = dest_p0;
+                    for (var i = 0; i < src_p1.length; ++i) {
+                        result_33557318[i] = nimCopy(result_33557318[i], src_p1[i], ti_p2.base);
+                    }
+                }
+            }
+            break;
+        case 24:
+        case 27:
+            if (src_p1 === null) {
+                result_33557318 = null;
+            }
+            else {
+                if (dest_p0 === null ||
+                    dest_p0 === undefined ||
+                    dest_p0.length != src_p1.length) {
+                    dest_p0 = new Array(src_p1.length);
+                }
+                result_33557318 = dest_p0;
+                for (var i = 0; i < src_p1.length; ++i) {
+                    result_33557318[i] = nimCopy(result_33557318[i], src_p1[i], ti_p2.base);
+                }
+            }
+            break;
+        case 28:
+            if (src_p1 !== null) {
+                result_33557318 = src_p1.slice(0);
+            }
+            break;
+        default:
+            result_33557318 = src_p1;
+            break;
+    }
+    return result_33557318;
+}
+function chckIndx(i_p0, a_p1, b_p2) {
+    var result_33557353 = 0;
+    BeforeRet: {
+        if (a_p1 <= i_p0 && i_p0 <= b_p2) {
+            result_33557353 = i_p0;
+            break BeforeRet;
+        }
+        else {
+            raiseIndexError(i_p0, a_p1, b_p2);
+        }
+    }
+    return result_33557353;
+}
+function add__system_u1943(x_p0, x_p0_Idx, y_p1) {
+    if (x_p0[x_p0_Idx] === null) {
+        x_p0[x_p0_Idx] = [];
+    }
+    var off = x_p0[x_p0_Idx].length;
+    x_p0[x_p0_Idx].length += y_p1.length;
+    for (var i = 0; i < y_p1.length; ++i) {
+        x_p0[x_p0_Idx][off + i] = y_p1.charCodeAt(i);
+    }
+}
+function newSeq__system_u2508(len_p0) {
+    var result_33556944 = [];
+    result_33556944 = new Array(len_p0);
+    for (var i = 0; i < len_p0; ++i) {
+        result_33556944[i] = null;
+    }
+    return result_33556944;
+}
+function unhandledException(e_p0) {
+    var buf_33556659 = [[]];
+    if (!(e_p0.message.length == 0)) {
+        buf_33556659[0].push.apply(buf_33556659[0], [
+            69, 114, 114, 111, 114, 58, 32, 117, 110, 104, 97, 110, 100, 108, 101,
+            100, 32, 101, 120, 99, 101, 112, 116, 105, 111, 110, 58, 32
+        ]);
+        buf_33556659[0].push.apply(buf_33556659[0], e_p0.message);
+    }
+    else {
+        buf_33556659[0].push.apply(buf_33556659[0], [
+            69, 114, 114, 111, 114, 58, 32, 117, 110, 104, 97, 110, 100, 108, 101,
+            100, 32, 101, 120, 99, 101, 112, 116, 105, 111, 110
+        ]);
+    }
+    buf_33556659[0].push.apply(buf_33556659[0], [32, 91]);
+    add__system_u1943(buf_33556659, 0, e_p0.name);
+    buf_33556659[0].push.apply(buf_33556659[0], [93, 10]);
+    var cbuf_33556660 = toJSStr(buf_33556659[0]);
+    if (typeof Error !== "undefined") {
+        throw new Error(cbuf_33556660);
+    }
+    else {
+        throw cbuf_33556660;
+    }
+}
+function raiseDivByZero() {
+    raiseException({
+        message: [
+            100, 105, 118, 105, 115, 105, 111, 110, 32, 98, 121, 32, 122, 101, 114,
+            111
+        ],
+        parent: null,
+        m_type: NTI134217742,
+        name: null,
+        trace: [],
+        up: null
+    }, "DivByZeroDefect");
+}
+function raiseOverflow() {
+    raiseException({
+        message: [
+            111, 118, 101, 114, 45, 32, 111, 114, 32, 117, 110, 100, 101, 114, 102,
+            108, 111, 119
+        ],
+        parent: null,
+        m_type: NTI134217743,
+        name: null,
+        trace: [],
+        up: null
+    }, "OverflowDefect");
+}
+function checkOverflowInt(a_p0) {
+    if (a_p0 > 2147483647 || a_p0 < -2147483648)
+        raiseOverflow();
+}
+function raiseRangeError() {
+    raiseException({
+        message: [
+            118, 97, 108, 117, 101, 32, 111, 117, 116, 32, 111, 102, 32, 114, 97,
+            110, 103, 101
+        ],
+        parent: null,
+        m_type: NTI134217751,
+        name: null,
+        trace: [],
+        up: null
+    }, "RangeDefect");
+}
+function addChars__stdZprivateZdigitsutils_u202(result_p0, result_p0_Idx, x_p1, start_p2, n_p3) {
+    var Temporary1;
+    var old_301990096 = result_p0[result_p0_Idx].length;
+    if (result_p0[result_p0_Idx].length <
+        ((Temporary1 = chckRange(addInt(old_301990096, n_p3), 0, 2147483647)),
+            Temporary1)) {
+        for (var i = result_p0[result_p0_Idx].length; i < Temporary1; ++i)
+            result_p0[result_p0_Idx].push(0);
+    }
+    else {
+        result_p0[result_p0_Idx].length = Temporary1;
+    }
+    {
+        var iHEX60gensym4_301990110 = 0;
+        var i_536870936 = 0;
+        {
+            Label4: while (true) {
+                if (!(i_536870936 < n_p3))
+                    break Label4;
+                iHEX60gensym4_301990110 = i_536870936;
+                result_p0[result_p0_Idx][chckIndx(addInt(old_301990096, iHEX60gensym4_301990110), 0, result_p0[result_p0_Idx].length - 1)] = x_p1.charCodeAt(chckIndx(addInt(start_p2, iHEX60gensym4_301990110), 0, x_p1.length - 1));
+                i_536870936 = addInt(i_536870936, 1);
+            }
+        }
+    }
+}
+function addChars__stdZprivateZdigitsutils_u198(result_p0, result_p0_Idx, x_p1) {
+    addChars__stdZprivateZdigitsutils_u202(result_p0, result_p0_Idx, x_p1, 0, x_p1 == null ? 0 : x_p1.length);
+}
+function addInt__stdZprivateZdigitsutils_u223(result_p0, result_p0_Idx, x_p1) {
+    addChars__stdZprivateZdigitsutils_u198(result_p0, result_p0_Idx, x_p1 + "");
+}
+function addInt__stdZprivateZdigitsutils_u241(result_p0, result_p0_Idx, x_p1) {
+    addInt__stdZprivateZdigitsutils_u223(result_p0, result_p0_Idx, x_p1);
+}
+function HEX24__systemZdollars_u8(x_p0) {
+    var result_385875978 = [[]];
+    addInt__stdZprivateZdigitsutils_u241(result_385875978, 0, x_p0);
+    return result_385875978[0];
+}
+function isFatPointer__system_u2866(ti_p0) {
+    var result_33557300 = false;
+    BeforeRet: {
+        result_33557300 = !(ConstSet1[ti_p0.base.kind] != undefined);
+        break BeforeRet;
+    }
+    return result_33557300;
+}
+function nimCopyAux(dest_p0, src_p1, n_p2) {
+    switch (n_p2.kind) {
+        case 0:
+            break;
+        case 1:
+            dest_p0[n_p2.offset] = nimCopy(dest_p0[n_p2.offset], src_p1[n_p2.offset], n_p2.typ);
+            break;
+        case 2:
+            for (var i = 0; i < n_p2.sons.length; i++) {
+                nimCopyAux(dest_p0, src_p1, n_p2.sons[i]);
+            }
+            break;
+        case 3:
+            dest_p0[n_p2.offset] = nimCopy(dest_p0[n_p2.offset], src_p1[n_p2.offset], n_p2.typ);
+            for (var i = 0; i < n_p2.sons.length; ++i) {
+                nimCopyAux(dest_p0, src_p1, n_p2.sons[i][1]);
+            }
+            break;
+    }
+}
+function raiseIndexError(i_p0, a_p1, b_p2) {
+    var Temporary1;
+    if (b_p2 < a_p1) {
+        Temporary1 = [
+            105, 110, 100, 101, 120, 32, 111, 117, 116, 32, 111, 102, 32, 98, 111,
+            117, 110, 100, 115, 44, 32, 116, 104, 101, 32, 99, 111, 110, 116, 97, 105,
+            110, 101, 114, 32, 105, 115, 32, 101, 109, 112, 116, 121
+        ];
+    }
+    else {
+        Temporary1 = [105, 110, 100, 101, 120, 32].concat(HEX24__systemZdollars_u8(i_p0), [32, 110, 111, 116, 32, 105, 110, 32], HEX24__systemZdollars_u8(a_p1), [32, 46, 46, 32], HEX24__systemZdollars_u8(b_p2));
+    }
+    raiseException({
+        message: nimCopy(null, Temporary1, NTI33554449),
+        parent: null,
+        m_type: NTI134217749,
+        name: null,
+        trace: [],
+        up: null
+    }, "IndexDefect");
+}
+function imul__pureZhashes_u340(a_p0, b_p1) {
+    var result_671088983 = 0;
+    var mask_671088984 = 65535;
+    var aHi_671088989 = ((a_p0 >>> 16) & mask_671088984) >>> 0;
+    var aLo_671088990 = (a_p0 & mask_671088984) >>> 0;
+    var bHi_671088995 = ((b_p1 >>> 16) & mask_671088984) >>> 0;
+    var bLo_671088996 = (b_p1 & mask_671088984) >>> 0;
+    result_671088983 =
+        (((aLo_671088990 * bLo_671088996) >>> 0) +
+            ((((((aHi_671088989 * bLo_671088996) >>> 0) +
+                ((aLo_671088990 * bHi_671088995) >>> 0)) >>>
+                0) <<
+                16) >>>
+                0)) >>>
+            0;
+    return result_671088983;
+}
+function rotl32__pureZhashes_u361(x_p0, r_p1) {
+    var result_671089004 = 0;
+    result_671089004 =
+        (((x_p0 << r_p1) >>> 0) | (x_p0 >>> subInt(32, r_p1))) >>> 0;
+    return result_671089004;
+}
+function murmurHash__pureZhashes_u373(x_p0) {
+    var result_671089015 = 0;
+    BeforeRet: {
+        var size_671089024 = x_p0.length;
+        var stepSize_671089025 = 4;
+        var n_671089026 = divInt(size_671089024, stepSize_671089025);
+        var h1_671089027 = 0;
+        var i_671089028 = 0;
+        {
+            Label2: while (true) {
+                if (!(i_671089028 < mulInt(n_671089026, stepSize_671089025)))
+                    break Label2;
+                var k1_671089031 = 0;
+                var jHEX60gensym11_671089048 = stepSize_671089025;
+                {
+                    Label4: while (true) {
+                        if (!(0 < jHEX60gensym11_671089048))
+                            break Label4;
+                        jHEX60gensym11_671089048 = subInt(jHEX60gensym11_671089048, 1);
+                        k1_671089031 =
+                            (((k1_671089031 << 8) >>> 0) |
+                                Number(BigInt.asUintN(32, BigInt(x_p0[chckIndx(addInt(i_671089028, jHEX60gensym11_671089048), 0, x_p0.length - 1)])))) >>>
+                                0;
+                    }
+                }
+                i_671089028 = addInt(i_671089028, stepSize_671089025);
+                k1_671089031 = imul__pureZhashes_u340(k1_671089031, 3432918353);
+                k1_671089031 = rotl32__pureZhashes_u361(k1_671089031, 15);
+                k1_671089031 = imul__pureZhashes_u340(k1_671089031, 461845907);
+                h1_671089027 = (h1_671089027 ^ k1_671089031) >>> 0;
+                h1_671089027 = rotl32__pureZhashes_u361(h1_671089027, 13);
+                h1_671089027 = (((h1_671089027 * 5) >>> 0) + 3864292196) >>> 0;
+            }
+        }
+        var k1_671089066 = 0;
+        var rem_671089067 = modInt(size_671089024, stepSize_671089025);
+        {
+            Label6: while (true) {
+                if (!(0 < rem_671089067))
+                    break Label6;
+                rem_671089067 = subInt(rem_671089067, 1);
+                k1_671089066 =
+                    (((k1_671089066 << 8) >>> 0) |
+                        Number(BigInt.asUintN(32, BigInt(x_p0[chckIndx(addInt(i_671089028, rem_671089067), 0, x_p0.length - 1)])))) >>>
+                        0;
+            }
+        }
+        k1_671089066 = imul__pureZhashes_u340(k1_671089066, 3432918353);
+        k1_671089066 = rotl32__pureZhashes_u361(k1_671089066, 15);
+        k1_671089066 = imul__pureZhashes_u340(k1_671089066, 461845907);
+        h1_671089027 = (h1_671089027 ^ k1_671089066) >>> 0;
+        h1_671089027 =
+            (h1_671089027 ^ Number(BigInt.asUintN(32, BigInt(size_671089024)))) >>> 0;
+        h1_671089027 = (h1_671089027 ^ (h1_671089027 >>> 16)) >>> 0;
+        h1_671089027 = imul__pureZhashes_u340(h1_671089027, 2246822507);
+        h1_671089027 = (h1_671089027 ^ (h1_671089027 >>> 13)) >>> 0;
+        h1_671089027 = imul__pureZhashes_u340(h1_671089027, 3266489909);
+        h1_671089027 = (h1_671089027 ^ (h1_671089027 >>> 16)) >>> 0;
+        result_671089015 = Number(BigInt.asIntN(32, BigInt(h1_671089027)));
+        break BeforeRet;
+    }
+    return result_671089015;
+}
+function hash__pureZhashes_u782(x_p0) {
+    var result_671089424 = 0;
+    result_671089424 = murmurHash__pureZhashes_u373(x_p0.slice(0, x_p0.length - 1 + 1));
+    return result_671089424;
+}
+function hashN__nim95hash_u2(item_p0, n_p1, maxValue_p2) {
+    var result_536870918 = 0;
+    var hashA_536870919 = modInt(absInt(hash__pureZhashes_u782(item_p0)), maxValue_p2);
+    var hashB_536870920 = modInt(absInt(hash__pureZhashes_u782(item_p0.concat([32, 98]))), maxValue_p2);
+    result_536870918 = modInt(absInt(addInt(hashA_536870919, mulInt(n_p1, hashB_536870920))), maxValue_p2);
+    return result_536870918;
+}
+function sysFatal__stdZassertions_u45(message_p1) {
+    raiseException({
+        message: nimCopy(null, message_p1, NTI33554449),
+        m_type: NTI134217745,
+        parent: null,
+        name: null,
+        trace: [],
+        up: null
+    }, "AssertionDefect");
+}
+function raiseAssert__stdZassertions_u43(msg_p0) {
+    sysFatal__stdZassertions_u45(msg_p0);
+}
+function failedAssertImpl__stdZassertions_u85(msg_p0) {
+    raiseAssert__stdZassertions_u43(msg_p0);
+}
+if (!(hashN__nim95hash_u2([100, 117, 109, 109, 121], 0, 1) == 0)) {
+    failedAssertImpl__stdZassertions_u85([
+        110, 105, 109, 95, 104, 97, 115, 104, 46, 110, 105, 109, 40, 50, 54, 44, 32,
+        51, 41, 32, 96, 104, 97, 115, 104, 78, 40, 34, 100, 117, 109, 109, 121, 34,
+        44, 32, 48, 44, 32, 49, 41, 32, 61, 61, 32, 48, 96, 32
+    ]);
+}
+
+// This file contains the probability tables used to determine the optimal number of
+// hash functions (k) and bits per element (m/n) for a Bloom filter.
+//
+// These are used to determine how to construct a Bloom filter that can perform
+// lookups with false-positive rate low enough to be satisfactory.
+/**
+ * Table of false positive rates for values of k from 0 to 12, and bits-per-element
+ * ratios ranging from 0 up to around 32. Each Float32Array is indexed by mOverN,
+ * so kErrors[k][mOverN] gives the estimated false-positive probability.
+ *
+ * These values mirror commonly used reference data found in Bloom filter literature,
+ * such as:
+ * https://pages.cs.wisc.edu/~cao/papers/summary-cache/node8.html
+ * https://dl.acm.org/doi/pdf/10.1145/362686.362692
+ */
+// prettier-ignore
+const kErrors = [
+    new Float32Array([1.0]),
+    new Float32Array([1.0, 1.0, 0.3930000000, 0.2830000000, 0.2210000000, 0.1810000000,
+        0.1540000000, 0.1330000000, 0.1180000000, 0.1050000000, 0.0952000000,
+        0.0869000000, 0.0800000000, 0.0740000000, 0.0689000000, 0.0645000000,
+        0.0606000000, 0.0571000000, 0.0540000000, 0.0513000000, 0.0488000000,
+        0.0465000000, 0.0444000000, 0.0425000000, 0.0408000000, 0.0392000000,
+        0.0377000000, 0.0364000000, 0.0351000000, 0.0339000000, 0.0328000000,
+        0.0317000000, 0.0308000000]),
+    new Float32Array([1.0, 1.0, 0.4000000000, 0.2370000000, 0.1550000000, 0.1090000000,
+        0.0804000000, 0.0618000000, 0.0489000000, 0.0397000000, 0.0329000000,
+        0.0276000000, 0.0236000000, 0.0203000000, 0.0177000000, 0.0156000000,
+        0.0138000000, 0.0123000000, 0.0111000000, 0.0099800000, 0.0090600000,
+        0.0082500000, 0.0075500000, 0.0069400000, 0.0063900000, 0.0059100000,
+        0.0054800000, 0.0051000000, 0.0047500000, 0.0044400000, 0.0041600000,
+        0.0039000000, 0.0036700000]),
+    new Float32Array([1.0, 1.0, 1.0, 0.2530000000, 0.1470000000, 0.0920000000,
+        0.0609000000, 0.0423000000, 0.0306000000, 0.0228000000, 0.0174000000,
+        0.0136000000, 0.0108000000, 0.0087500000, 0.0071800000, 0.0059600000,
+        0.0108000000, 0.0087500000, 0.0071800000, 0.0059600000, 0.0050000000,
+        0.0042300000, 0.0036200000, 0.0031200000, 0.0027000000, 0.0023600000,
+        0.0020700000, 0.0018300000, 0.0016200000, 0.0014500000, 0.0012900000,
+        0.0011600000, 0.0010500000, 0.0009490000, 0.0008620000, 0.0007850000,
+        0.0007170000]),
+    new Float32Array([1.0, 1.0, 1.0, 1.0, 0.1600000000, 0.0920000000, 0.0561000000, 0.0359000000,
+        0.0240000000, 0.0166000000, 0.0118000000, 0.0086400000, 0.0064600000,
+        0.0049200000, 0.0038100000, 0.0030000000, 0.0023900000, 0.0019300000,
+        0.0015800000, 0.0013000000, 0.0010800000, 0.0009050000, 0.0007640000,
+        0.0006490000, 0.0005550000, 0.0004780000, 0.0004130000, 0.0003590000,
+        0.0003140000, 0.0002760000, 0.0002430000, 0.0002150000, 0.0001910000]),
+    new Float32Array([1.0, 1.0, 1.0, 1.0, 1.0, 0.1010000000, 0.0578000000, 0.0347000000,
+        0.0217000000, 0.0141000000, 0.0094300000, 0.0065000000, 0.0045900000,
+        0.0033200000, 0.0024400000, 0.0018300000, 0.0013900000, 0.0010700000,
+        0.0008390000, 0.0006630000, 0.0005300000, 0.0004270000, 0.0003470000,
+        0.0002850000, 0.0002350000, 0.0001960000, 0.0001640000, 0.0001380000,
+        0.0001170000, 0.0000996000, 0.0000853000, 0.0000733000, 0.0000633000]),
+    new Float32Array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0638000000, 0.0364000000, 0.0216000000,
+        0.0133000000, 0.0084400000, 0.0055200000, 0.0037100000, 0.0025500000,
+        0.0017900000, 0.0012800000, 0.0009350000, 0.0006920000, 0.0005190000,
+        0.0003940000, 0.0003030000, 0.0002360000, 0.0001850000, 0.0001470000,
+        0.0001170000, 0.0000944000, 0.0000766000, 0.0000626000, 0.0000515000,
+        0.0000426000, 0.0000355000, 0.0000297000, 0.0000250000]),
+    new Float32Array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0229000000, 0.0135000000, 0.0081900000,
+        0.0051300000, 0.0032900000, 0.0021700000, 0.0014600000, 0.0010000000,
+        0.0007020000, 0.0004990000, 0.0003600000, 0.0002640000, 0.0001960000,
+        0.0001470000, 0.0001120000, 0.0000856000, 0.0000663000, 0.0000518000,
+        0.0000408000, 0.0000324000, 0.0000259000, 0.0000209000, 0.0000169000,
+        0.0000138000, 0.0000113000]),
+    new Float32Array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+        1.0, 0.0145000000, 0.0084600000, 0.0050900000, 0.0031400000, 0.0019900000,
+        0.0012900000, 0.0008520000, 0.0005740000, 0.0003940000, 0.0002750000,
+        0.0001940000, 0.0001400000, 0.0001010000, 0.0000746000, 0.0000555000,
+        0.0000417000, 0.0000316000, 0.0000242000, 0.0000187000, 0.0000146000,
+        0.0000114000, 0.0000090100, 0.0000071600, 0.0000057300]),
+    new Float32Array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0053100000, 0.0031700000,
+        0.0019400000, 0.0012100000, 0.0007750000, 0.0005050000, 0.0003350000,
+        0.0002260000, 0.0001550000, 0.0001080000, 0.0000759000, 0.0000542000,
+        0.0000392000, 0.0000286000, 0.0000211000, 0.0000157000, 0.0000118000,
+        0.0000089600, 0.0000068500, 0.0000052800, 0.0000041000, 0.0000032000]),
+    new Float32Array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0033400000,
+        0.0019800000, 0.0012000000, 0.0007440000, 0.0004700000, 0.0003020000,
+        0.0001980000, 0.0001320000, 0.0000889000, 0.0000609000, 0.0000423000,
+        0.0000297000, 0.0000211000, 0.0000152000, 0.0000110000, 0.0000080700,
+        0.0000059700, 0.0000044500, 0.0000033500, 0.0000025400, 0.0000019400]),
+    new Float32Array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+        0.0021000000, 0.0012400000, 0.0007470000, 0.0004590000, 0.0002870000,
+        0.0001830000, 0.0001180000, 0.0000777000, 0.0000518000, 0.0000350000,
+        0.0000240000, 0.0000166000, 0.0000116000, 0.0000082300, 0.0000058900,
+        0.0000042500, 0.0000031000, 0.0000022800, 0.0000016900, 0.0000012600]),
+    new Float32Array([1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+        0.0007780000, 0.0004660000, 0.0002840000, 0.0001760000, 0.0001110000,
+        0.0000712000, 0.0000463000, 0.0000305000, 0.0000204000, 0.0000138000,
+        0.0000094200, 0.0000065200, 0.0000045600, 0.0000032200, 0.0000022900,
+        0.0000016500, 0.0000012000, 0.0000008740]),
+];
+const KTooLargeError = "K must be <= 12";
+const NoSuitableRatioError = "Specified value of k and error rate not achievable using less than 4 bytes / element.";
+/**
+ * Given a number of hash functions (k) and a target false-positive rate (targetError),
+ * determines the minimum (m/n) bits-per-element that satisfies the error threshold.
+ *
+ * In the context of a Bloom filter:
+ * - m is the total number of bits in the filter.
+ * - n is the number of elements you expect to insert.
+ * Thus, (m/n) describes how many bits are assigned per inserted element.
+ *
+ * Example:
+ * ```ts
+ * // We want to use 3 hash functions (k=3) and a false-positive rate of 1% (targetError=0.01).
+ * const mOverN = getMOverNBitsForK(3, 0.01);
+ * // The function will iterate through the error tables and find the smallest m/n that satisfies the error threshold.
+ * // In this case, kErrors[3][5] is the first value in the vector kErrors[3] that is less than 0.01 (0.0920000000).
+ * console.log(mOverN); // 5
+ * ```
+ *
+ * @param k - The number of hash functions.
+ * @param targetError - The desired maximum false-positive rate.
+ * @param probabilityTable - An optional table of false-positive probabilities indexed by k.
+ * @returns The smallest (m/n) bit ratio for which the false-positive rate is below targetError.
+ * @throws If k is out of range or if no suitable ratio can be found.
+ */
+function getMOverNBitsForK(k, targetError, probabilityTable = kErrors) {
+    // Returns the optimal number of m/n bits for a given k.
+    if (k < 0 || k > 12) {
+        throw new Error(KTooLargeError);
+    }
+    for (let mOverN = 2; mOverN < probabilityTable[k].length; mOverN++) {
+        if (probabilityTable[k][mOverN] < targetError) {
+            return mOverN;
+        }
+    }
+    throw new Error(NoSuitableRatioError);
+}
+
+const sizeOfInt = 8;
+/**
+ * A probabilistic data structure that tracks memberships in a set.
+ * Supports time and space efficient lookups, but may return false-positives.
+ * Can never return false-negatives.
+ * A bloom filter can tell us if an element is:
+ * - Definitely not in the set
+ * - Potentially in the set (with a probability depending on the false-positive rate)
+ */
+class BloomFilter {
+    totalBits;
+    data = [];
+    kHashes;
+    errorRate;
+    options;
+    hashN;
+    constructor(options, hashN) {
+        this.options = options;
+        let nBitsPerElem;
+        let k = options.kHashes ?? 0;
+        const forceNBitsPerElem = options.forceNBitsPerElem ?? 0;
+        if (k < 1) {
+            // Calculate optimal k based on target error rate
+            const bitsPerElem = Math.ceil(-1 * (Math.log(options.errorRate) / Math.pow(Math.log(2), 2)));
+            k = Math.round(Math.log(2) * bitsPerElem);
+            nBitsPerElem = Math.round(bitsPerElem);
+        }
+        else {
+            // Use specified k if possible
+            if (forceNBitsPerElem < 1) {
+                // Use lookup table
+                nBitsPerElem = getMOverNBitsForK(k, options.errorRate);
+            }
+            else {
+                nBitsPerElem = forceNBitsPerElem;
+            }
+        }
+        const mBits = options.capacity * nBitsPerElem;
+        const mInts = 1 + Math.floor(mBits / (sizeOfInt * 8));
+        this.totalBits = mBits;
+        this.data = new Array(mInts);
+        this.data.fill(BigInt(0));
+        this.kHashes = k;
+        this.hashN = hashN;
+        this.errorRate = options.errorRate;
+    }
+    computeHashes(item) {
+        const hashes = new Array(this.kHashes);
+        for (let i = 0; i < this.kHashes; i++) {
+            hashes[i] = this.hashN(item, i, this.totalBits);
+        }
+        return hashes;
+    }
+    // Adds an item to the bloom filter by computing its hash values
+    // and setting corresponding bits in "data".
+    insert(item) {
+        const hashSet = this.computeHashes(item);
+        for (const h of hashSet) {
+            const intAddress = Math.floor(h / (sizeOfInt * 8));
+            const bitOffset = h % (sizeOfInt * 8);
+            this.data[intAddress] =
+                this.data[intAddress] | (BigInt(1) << BigInt(bitOffset));
+        }
+    }
+    // Checks if the item is potentially in the bloom filter.
+    // The method is guaranteed to return "true" for items that were inserted,
+    // but might also return "true" for items that were never inserted
+    // (purpose of false-positive probability).
+    lookup(item) {
+        const hashSet = this.computeHashes(item);
+        for (const h of hashSet) {
+            const intAddress = Math.floor(h / (sizeOfInt * 8));
+            const bitOffset = h % (sizeOfInt * 8);
+            const currentInt = this.data[intAddress];
+            if (currentInt != (currentInt | (BigInt(1) << BigInt(bitOffset)))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    toBytes() {
+        const buffer = new ArrayBuffer(this.data.length * 8);
+        const view = new DataView(buffer);
+        for (let i = 0; i < this.data.length; i++) {
+            view.setBigInt64(i * 8, this.data[i]);
+        }
+        return new Uint8Array(buffer);
+    }
+    static fromBytes(bytes, options, hashN) {
+        const bloomFilter = new BloomFilter(options, hashN);
+        const view = new DataView(bytes.buffer);
+        for (let i = 0; i < bloomFilter.data.length; i++) {
+            bloomFilter.data[i] = view.getBigUint64(i * 8, false);
+        }
+        return bloomFilter;
+    }
+}
+
+export { BloomFilter };