@waku/rln 0.1.8-e224c05.0 → 0.1.8-e800af3.0

package/bundle/node_modules/multiformats/dist/src/hashes/digest.js

@@ -0,0 +1,62 @@
+import { equals as equals$1, coerce } from '../bytes.js';
+import { encodeTo, decode as decode$1, encodingLength } from '../varint.js';
+
+/**
+ * Creates a multihash digest.
+ */
+function create(code, digest) {
+    const size = digest.byteLength;
+    const sizeOffset = encodingLength(code);
+    const digestOffset = sizeOffset + encodingLength(size);
+    const bytes = new Uint8Array(digestOffset + size);
+    encodeTo(code, bytes, 0);
+    encodeTo(size, bytes, sizeOffset);
+    bytes.set(digest, digestOffset);
+    return new Digest(code, size, digest, bytes);
+}
+/**
+ * Turns bytes representation of multihash digest into an instance.
+ */
+function decode(multihash) {
+    const bytes = coerce(multihash);
+    const [code, sizeOffset] = decode$1(bytes);
+    const [size, digestOffset] = decode$1(bytes.subarray(sizeOffset));
+    const digest = bytes.subarray(sizeOffset + digestOffset);
+    if (digest.byteLength !== size) {
+        throw new Error('Incorrect length');
+    }
+    return new Digest(code, size, digest, bytes);
+}
+function equals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    else {
+        const data = b;
+        return (a.code === data.code &&
+            a.size === data.size &&
+            data.bytes instanceof Uint8Array &&
+            equals$1(a.bytes, data.bytes));
+    }
+}
+/**
+ * Represents a multihash digest which carries information about the
+ * hashing algorithm and an actual hash digest.
+ */
+class Digest {
+    code;
+    size;
+    digest;
+    bytes;
+    /**
+     * Creates a multihash digest.
+     */
+    constructor(code, size, digest, bytes) {
+        this.code = code;
+        this.size = size;
+        this.digest = digest;
+        this.bytes = bytes;
+    }
+}
+
+export { Digest, create, decode, equals };

package/bundle/node_modules/multiformats/dist/src/varint.js

@@ -0,0 +1,15 @@
+import _brrp_varint from './vendor/varint.js';
+
+function decode(data, offset = 0) {
+    const code = _brrp_varint.decode(data, offset);
+    return [code, _brrp_varint.decode.bytes];
+}
+function encodeTo(int, target, offset = 0) {
+    _brrp_varint.encode(int, target, offset);
+    return target;
+}
+function encodingLength(int) {
+    return _brrp_varint.encodingLength(int);
+}
+
+export { decode, encodeTo, encodingLength };

package/bundle/node_modules/multiformats/dist/src/vendor/varint.js

@@ -0,0 +1,78 @@
+/* eslint-disable */
+var encode_1 = encode;
+var MSB = 0x80, MSBALL = -128, INT = Math.pow(2, 31);
+/**
+ * @param {number} num
+ * @param {number[]} out
+ * @param {number} offset
+ */
+function encode(num, out, offset) {
+    out = out || [];
+    offset = offset || 0;
+    var oldOffset = offset;
+    while (num >= INT) {
+        out[offset++] = (num & 0xFF) | MSB;
+        num /= 128;
+    }
+    while (num & MSBALL) {
+        out[offset++] = (num & 0xFF) | MSB;
+        num >>>= 7;
+    }
+    out[offset] = num | 0;
+    // @ts-ignore
+    encode.bytes = offset - oldOffset + 1;
+    return out;
+}
+var decode = read;
+var MSB$1 = 0x80, REST$1 = 0x7F;
+/**
+ * @param {string | any[]} buf
+ * @param {number} offset
+ */
+function read(buf, offset) {
+    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+    do {
+        if (counter >= l) {
+            // @ts-ignore
+            read.bytes = 0;
+            throw new RangeError('Could not decode varint');
+        }
+        b = buf[counter++];
+        res += shift < 28
+            ? (b & REST$1) << shift
+            : (b & REST$1) * Math.pow(2, shift);
+        shift += 7;
+    } while (b >= MSB$1);
+    // @ts-ignore
+    read.bytes = counter - offset;
+    return res;
+}
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var length = function (/** @type {number} */ value) {
+    return (value < N1 ? 1
+        : value < N2 ? 2
+            : value < N3 ? 3
+                : value < N4 ? 4
+                    : value < N5 ? 5
+                        : value < N6 ? 6
+                            : value < N7 ? 7
+                                : value < N8 ? 8
+                                    : value < N9 ? 9
+                                        : 10);
+};
+var varint = {
+    encode: encode_1,
+    decode: decode,
+    encodingLength: length
+};
+var _brrp_varint = varint;
+
+export { _brrp_varint 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 };