@waku/rln 0.1.3-f6d5deb → 0.1.4-29a4c3f.0

package/bundle/node_modules/multiformats/dist/src/vendor/base-x.js

@@ -0,0 +1,170 @@
+/* eslint-disable */
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+/**
+ * @param {string} ALPHABET
+ * @param {any} name
+ */
+function base(ALPHABET, name) {
+    if (ALPHABET.length >= 255) {
+        throw new TypeError('Alphabet too long');
+    }
+    var BASE_MAP = new Uint8Array(256);
+    for (var j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+    }
+    for (var i = 0; i < ALPHABET.length; i++) {
+        var x = ALPHABET.charAt(i);
+        var xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+            throw new TypeError(x + ' is ambiguous');
+        }
+        BASE_MAP[xc] = i;
+    }
+    var BASE = ALPHABET.length;
+    var LEADER = ALPHABET.charAt(0);
+    var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
+    var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+    /**
+     * @param {any[] | Iterable<number>} source
+     */
+    function encode(source) {
+        // @ts-ignore
+        if (source instanceof Uint8Array)
+            ;
+        else if (ArrayBuffer.isView(source)) {
+            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        }
+        else if (Array.isArray(source)) {
+            source = Uint8Array.from(source);
+        }
+        if (!(source instanceof Uint8Array)) {
+            throw new TypeError('Expected Uint8Array');
+        }
+        if (source.length === 0) {
+            return '';
+        }
+        // Skip & count leading zeroes.
+        var zeroes = 0;
+        var length = 0;
+        var pbegin = 0;
+        var pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+            pbegin++;
+            zeroes++;
+        }
+        // Allocate enough space in big-endian base58 representation.
+        var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        var b58 = new Uint8Array(size);
+        // Process the bytes.
+        while (pbegin !== pend) {
+            var carry = source[pbegin];
+            // Apply "b58 = b58 * 256 + ch".
+            var i = 0;
+            for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+                carry += (256 * b58[it1]) >>> 0;
+                b58[it1] = (carry % BASE) >>> 0;
+                carry = (carry / BASE) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            pbegin++;
+        }
+        // Skip leading zeroes in base58 result.
+        var it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+            it2++;
+        }
+        // Translate the result into a string.
+        var str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+            str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+    }
+    /**
+     * @param {string | string[]} source
+     */
+    function decodeUnsafe(source) {
+        if (typeof source !== 'string') {
+            throw new TypeError('Expected String');
+        }
+        if (source.length === 0) {
+            return new Uint8Array();
+        }
+        var psz = 0;
+        // Skip leading spaces.
+        if (source[psz] === ' ') {
+            return;
+        }
+        // Skip and count leading '1's.
+        var zeroes = 0;
+        var length = 0;
+        while (source[psz] === LEADER) {
+            zeroes++;
+            psz++;
+        }
+        // Allocate enough space in big-endian base256 representation.
+        var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
+        var b256 = new Uint8Array(size);
+        // Process the characters.
+        while (source[psz]) {
+            // Decode character
+            var carry = BASE_MAP[source.charCodeAt(psz)];
+            // Invalid character
+            if (carry === 255) {
+                return;
+            }
+            var i = 0;
+            for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+                carry += (BASE * b256[it3]) >>> 0;
+                b256[it3] = (carry % 256) >>> 0;
+                carry = (carry / 256) >>> 0;
+            }
+            if (carry !== 0) {
+                throw new Error('Non-zero carry');
+            }
+            length = i;
+            psz++;
+        }
+        // Skip trailing spaces.
+        if (source[psz] === ' ') {
+            return;
+        }
+        // Skip leading zeroes in b256.
+        var it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+            it4++;
+        }
+        var vch = new Uint8Array(zeroes + (size - it4));
+        var j = zeroes;
+        while (it4 !== size) {
+            vch[j++] = b256[it4++];
+        }
+        return vch;
+    }
+    /**
+     * @param {string | string[]} string
+     */
+    function decode(string) {
+        var buffer = decodeUnsafe(string);
+        if (buffer) {
+            return buffer;
+        }
+        throw new Error(`Non-${name} character`);
+    }
+    return {
+        encode: encode,
+        decodeUnsafe: decodeUnsafe,
+        decode: decode
+    };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+
+export { _brrp__multiformats_scope_baseX as default };

package/bundle/node_modules/protons-runtime/dist/src/codec.js

@@ -0,0 +1,20 @@
+// https://developers.google.com/protocol-buffers/docs/encoding#structure
+var CODEC_TYPES;
+(function (CODEC_TYPES) {
+    CODEC_TYPES[CODEC_TYPES["VARINT"] = 0] = "VARINT";
+    CODEC_TYPES[CODEC_TYPES["BIT64"] = 1] = "BIT64";
+    CODEC_TYPES[CODEC_TYPES["LENGTH_DELIMITED"] = 2] = "LENGTH_DELIMITED";
+    CODEC_TYPES[CODEC_TYPES["START_GROUP"] = 3] = "START_GROUP";
+    CODEC_TYPES[CODEC_TYPES["END_GROUP"] = 4] = "END_GROUP";
+    CODEC_TYPES[CODEC_TYPES["BIT32"] = 5] = "BIT32";
+})(CODEC_TYPES || (CODEC_TYPES = {}));
+function createCodec(name, type, encode, decode) {
+    return {
+        name,
+        type,
+        encode,
+        decode
+    };
+}
+
+export { CODEC_TYPES, createCodec };

package/bundle/node_modules/protons-runtime/dist/src/codecs/enum.js

@@ -0,0 +1,24 @@
+import { createCodec, CODEC_TYPES } from '../codec.js';
+
+function enumeration(v) {
+    function findValue(val) {
+        // Use the reverse mapping to look up the enum key for the stored value
+        // https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings
+        if (v[val.toString()] == null) {
+            throw new Error('Invalid enum value');
+        }
+        return v[val];
+    }
+    const encode = function enumEncode(val, writer) {
+        const enumValue = findValue(val);
+        writer.int32(enumValue);
+    };
+    const decode = function enumDecode(reader) {
+        const val = reader.int32();
+        return findValue(val);
+    };
+    // @ts-expect-error yeah yeah
+    return createCodec('enum', CODEC_TYPES.VARINT, encode, decode);
+}
+
+export { enumeration };

package/bundle/node_modules/protons-runtime/dist/src/codecs/message.js

@@ -0,0 +1,7 @@
+import { createCodec, CODEC_TYPES } from '../codec.js';
+
+function message(encode, decode) {
+    return createCodec('message', CODEC_TYPES.LENGTH_DELIMITED, encode, decode);
+}
+
+export { message };

package/bundle/node_modules/protons-runtime/dist/src/decode.js

@@ -0,0 +1,8 @@
+import { createReader } from './utils/reader.js';
+
+function decodeMessage(buf, codec, opts) {
+    const reader = createReader(buf);
+    return codec.decode(reader, undefined, opts);
+}
+
+export { decodeMessage };

package/bundle/node_modules/protons-runtime/dist/src/encode.js

@@ -0,0 +1,11 @@
+import { createWriter } from './utils/writer.js';
+
+function encodeMessage(message, codec) {
+    const w = createWriter();
+    codec.encode(message, w, {
+        lengthDelimited: false
+    });
+    return w.finish();
+}
+
+export { encodeMessage };

package/bundle/node_modules/protons-runtime/dist/src/index.js

@@ -0,0 +1,30 @@
+import './utils/float.js';
+import './utils/longbits.js';
+export { createWriter as writer } from './utils/writer.js';
+import './codec.js';
+
+/**
+ * @packageDocumentation
+ *
+ * This module contains serialization/deserialization code used when encoding/decoding protobufs.
+ *
+ * It should be declared as a dependency of your project:
+ *
+ * ```console
+ * npm i protons-runtime
+ * ```
+ */
+/**
+ * Thrown when a repeated field has too many elements
+ */
+class MaxLengthError extends Error {
+    /**
+     * This will be removed in a future release
+     *
+     * @deprecated use the `.name` property instead
+     */
+    code = 'ERR_MAX_LENGTH';
+    name = 'MaxLengthError';
+}
+
+export { MaxLengthError };

package/bundle/node_modules/protons-runtime/dist/src/utils/float.js

@@ -0,0 +1,54 @@
+const f32 = new Float32Array([-0]);
+const f8b = new Uint8Array(f32.buffer);
+/**
+ * Writes a 32 bit float to a buffer using little endian byte order
+ */
+function writeFloatLE(val, buf, pos) {
+    f32[0] = val;
+    buf[pos] = f8b[0];
+    buf[pos + 1] = f8b[1];
+    buf[pos + 2] = f8b[2];
+    buf[pos + 3] = f8b[3];
+}
+/**
+ * Reads a 32 bit float from a buffer using little endian byte order
+ */
+function readFloatLE(buf, pos) {
+    f8b[0] = buf[pos];
+    f8b[1] = buf[pos + 1];
+    f8b[2] = buf[pos + 2];
+    f8b[3] = buf[pos + 3];
+    return f32[0];
+}
+const f64 = new Float64Array([-0]);
+const d8b = new Uint8Array(f64.buffer);
+/**
+ * Writes a 64 bit double to a buffer using little endian byte order
+ */
+function writeDoubleLE(val, buf, pos) {
+    f64[0] = val;
+    buf[pos] = d8b[0];
+    buf[pos + 1] = d8b[1];
+    buf[pos + 2] = d8b[2];
+    buf[pos + 3] = d8b[3];
+    buf[pos + 4] = d8b[4];
+    buf[pos + 5] = d8b[5];
+    buf[pos + 6] = d8b[6];
+    buf[pos + 7] = d8b[7];
+}
+/**
+ * Reads a 64 bit double from a buffer using little endian byte order
+ */
+function readDoubleLE(buf, pos) {
+    d8b[0] = buf[pos];
+    d8b[1] = buf[pos + 1];
+    d8b[2] = buf[pos + 2];
+    d8b[3] = buf[pos + 3];
+    d8b[4] = buf[pos + 4];
+    d8b[5] = buf[pos + 5];
+    d8b[6] = buf[pos + 6];
+    d8b[7] = buf[pos + 7];
+    return f64[0];
+}
+
+export { readDoubleLE, readFloatLE, writeDoubleLE, writeFloatLE };

package/bundle/node_modules/protons-runtime/dist/src/utils/longbits.js

@@ -0,0 +1,175 @@
+// the largest BigInt we can safely downcast to a Number
+const MAX_SAFE_NUMBER_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+const MIN_SAFE_NUMBER_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
+/**
+ * Constructs new long bits.
+ *
+ * @classdesc Helper class for working with the low and high bits of a 64 bit value.
+ * @memberof util
+ * @function Object() { [native code] }
+ * @param {number} lo - Low 32 bits, unsigned
+ * @param {number} hi - High 32 bits, unsigned
+ */
+class LongBits {
+    lo;
+    hi;
+    constructor(lo, hi) {
+        // note that the casts below are theoretically unnecessary as of today, but older statically
+        // generated converter code might still call the ctor with signed 32bits. kept for compat.
+        /**
+         * Low bits
+         */
+        this.lo = lo | 0;
+        /**
+         * High bits
+         */
+        this.hi = hi | 0;
+    }
+    /**
+     * Converts this long bits to a possibly unsafe JavaScript number
+     */
+    toNumber(unsigned = false) {
+        if (!unsigned && (this.hi >>> 31) > 0) {
+            const lo = ~this.lo + 1 >>> 0;
+            let hi = ~this.hi >>> 0;
+            if (lo === 0) {
+                hi = hi + 1 >>> 0;
+            }
+            return -(lo + hi * 4294967296);
+        }
+        return this.lo + this.hi * 4294967296;
+    }
+    /**
+     * Converts this long bits to a bigint
+     */
+    toBigInt(unsigned = false) {
+        if (unsigned) {
+            return BigInt(this.lo >>> 0) + (BigInt(this.hi >>> 0) << 32n);
+        }
+        if ((this.hi >>> 31) !== 0) {
+            const lo = ~this.lo + 1 >>> 0;
+            let hi = ~this.hi >>> 0;
+            if (lo === 0) {
+                hi = hi + 1 >>> 0;
+            }
+            return -(BigInt(lo) + (BigInt(hi) << 32n));
+        }
+        return BigInt(this.lo >>> 0) + (BigInt(this.hi >>> 0) << 32n);
+    }
+    /**
+     * Converts this long bits to a string
+     */
+    toString(unsigned = false) {
+        return this.toBigInt(unsigned).toString();
+    }
+    /**
+     * Zig-zag encodes this long bits
+     */
+    zzEncode() {
+        const mask = this.hi >> 31;
+        this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;
+        this.lo = (this.lo << 1 ^ mask) >>> 0;
+        return this;
+    }
+    /**
+     * Zig-zag decodes this long bits
+     */
+    zzDecode() {
+        const mask = -(this.lo & 1);
+        this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;
+        this.hi = (this.hi >>> 1 ^ mask) >>> 0;
+        return this;
+    }
+    /**
+     * Calculates the length of this longbits when encoded as a varint.
+     */
+    length() {
+        const part0 = this.lo;
+        const part1 = (this.lo >>> 28 | this.hi << 4) >>> 0;
+        const part2 = this.hi >>> 24;
+        return part2 === 0
+            ? part1 === 0
+                ? part0 < 16384
+                    ? part0 < 128 ? 1 : 2
+                    : part0 < 2097152 ? 3 : 4
+                : part1 < 16384
+                    ? part1 < 128 ? 5 : 6
+                    : part1 < 2097152 ? 7 : 8
+            : part2 < 128 ? 9 : 10;
+    }
+    /**
+     * Constructs new long bits from the specified number
+     */
+    static fromBigInt(value) {
+        if (value === 0n) {
+            return zero;
+        }
+        if (value < MAX_SAFE_NUMBER_INTEGER && value > MIN_SAFE_NUMBER_INTEGER) {
+            return this.fromNumber(Number(value));
+        }
+        const negative = value < 0n;
+        if (negative) {
+            value = -value;
+        }
+        let hi = value >> 32n;
+        let lo = value - (hi << 32n);
+        if (negative) {
+            hi = ~hi | 0n;
+            lo = ~lo | 0n;
+            if (++lo > TWO_32) {
+                lo = 0n;
+                if (++hi > TWO_32) {
+                    hi = 0n;
+                }
+            }
+        }
+        return new LongBits(Number(lo), Number(hi));
+    }
+    /**
+     * Constructs new long bits from the specified number
+     */
+    static fromNumber(value) {
+        if (value === 0) {
+            return zero;
+        }
+        const sign = value < 0;
+        if (sign) {
+            value = -value;
+        }
+        let lo = value >>> 0;
+        let hi = (value - lo) / 4294967296 >>> 0;
+        if (sign) {
+            hi = ~hi >>> 0;
+            lo = ~lo >>> 0;
+            if (++lo > 4294967295) {
+                lo = 0;
+                if (++hi > 4294967295) {
+                    hi = 0;
+                }
+            }
+        }
+        return new LongBits(lo, hi);
+    }
+    /**
+     * Constructs new long bits from a number, long or string
+     */
+    static from(value) {
+        if (typeof value === 'number') {
+            return LongBits.fromNumber(value);
+        }
+        if (typeof value === 'bigint') {
+            return LongBits.fromBigInt(value);
+        }
+        if (typeof value === 'string') {
+            return LongBits.fromBigInt(BigInt(value));
+        }
+        return value.low != null || value.high != null ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;
+    }
+}
+const zero = new LongBits(0, 0);
+zero.toBigInt = function () { return 0n; };
+zero.zzEncode = zero.zzDecode = function () { return this; };
+zero.length = function () { return 1; };
+const TWO_32 = 4294967296n;
+
+export { LongBits };

package/bundle/node_modules/protons-runtime/dist/src/utils/pool.js

@@ -0,0 +1,28 @@
+import { allocUnsafe } from '../../../../uint8arrays/dist/src/alloc.js';
+
+/**
+ * A general purpose buffer pool
+ */
+function pool(size) {
+    const SIZE = 8192;
+    const MAX = SIZE >>> 1;
+    let slab;
+    let offset = SIZE;
+    return function poolAlloc(size) {
+        if (size < 1 || size > MAX) {
+            return allocUnsafe(size);
+        }
+        if (offset + size > SIZE) {
+            slab = allocUnsafe(SIZE);
+            offset = 0;
+        }
+        const buf = slab.subarray(offset, offset += size);
+        if ((offset & 7) !== 0) {
+            // align to 32 bit
+            offset = (offset | 7) + 1;
+        }
+        return buf;
+    };
+}
+
+export { pool as default };