@waku/rln 0.1.6-f911bf8.0 → 0.1.6

package/bundle/node_modules/@multiformats/multiaddr/dist/src/registry.js

@@ -0,0 +1,245 @@
+import { isIPv4, isIPv6 } from '../../../../@chainsafe/is-ip/lib/is-ip.js';
+import { CID } from '../../../../multiformats/dist/src/cid.js';
+import { base64url } from '../../../../multiformats/dist/src/bases/base64.js';
+import { CODE_IP4, CODE_TCP, CODE_UDP, CODE_DCCP, CODE_IP6, CODE_IP6ZONE, CODE_IPCIDR, CODE_DNS, CODE_DNS4, CODE_DNS6, CODE_DNSADDR, CODE_SCTP, CODE_UDT, CODE_UTP, CODE_UNIX, CODE_P2P, CODE_ONION, CODE_ONION3, CODE_GARLIC64, CODE_GARLIC32, CODE_TLS, CODE_SNI, CODE_NOISE, CODE_QUIC, CODE_QUIC_V1, CODE_WEBTRANSPORT, CODE_CERTHASH, CODE_HTTP, CODE_HTTP_PATH, CODE_HTTPS, CODE_WS, CODE_WSS, CODE_P2P_WEBSOCKET_STAR, CODE_P2P_STARDUST, CODE_P2P_WEBRTC_STAR, CODE_P2P_WEBRTC_DIRECT, CODE_WEBRTC_DIRECT, CODE_WEBRTC, CODE_P2P_CIRCUIT, CODE_MEMORY } from './constants.js';
+import { ValidationError, UnknownProtocolError } from './errors.js';
+import { ip4ToString, ip4ToBytes, bytes2port, port2bytes, ip6StringToValue, ip6ToString, ip6ToBytes, stringToBytes, bytesToString, onion2bytes, bytes2onion, onion32bytes, mb2bytes, bytes2mb } from './utils.js';
+import { validatePort } from './validation.js';
+
+const V = -1;
+class Registry {
+    protocolsByCode = new Map();
+    protocolsByName = new Map();
+    getProtocol(key) {
+        let codec;
+        if (typeof key === 'string') {
+            codec = this.protocolsByName.get(key);
+        }
+        else {
+            codec = this.protocolsByCode.get(key);
+        }
+        if (codec == null) {
+            throw new UnknownProtocolError(`Protocol ${key} was unknown`);
+        }
+        return codec;
+    }
+    addProtocol(codec) {
+        this.protocolsByCode.set(codec.code, codec);
+        this.protocolsByName.set(codec.name, codec);
+        codec.aliases?.forEach(alias => {
+            this.protocolsByName.set(alias, codec);
+        });
+    }
+    removeProtocol(code) {
+        const codec = this.protocolsByCode.get(code);
+        if (codec == null) {
+            return;
+        }
+        this.protocolsByCode.delete(codec.code);
+        this.protocolsByName.delete(codec.name);
+        codec.aliases?.forEach(alias => {
+            this.protocolsByName.delete(alias);
+        });
+    }
+}
+const registry = new Registry();
+const codecs = [{
+        code: CODE_IP4,
+        name: 'ip4',
+        size: 32,
+        valueToBytes: ip4ToBytes,
+        bytesToValue: ip4ToString,
+        validate: (value) => {
+            if (!isIPv4(value)) {
+                throw new ValidationError(`Invalid IPv4 address "${value}"`);
+            }
+        }
+    }, {
+        code: CODE_TCP,
+        name: 'tcp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_UDP,
+        name: 'udp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_DCCP,
+        name: 'dccp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_IP6,
+        name: 'ip6',
+        size: 128,
+        valueToBytes: ip6ToBytes,
+        bytesToValue: ip6ToString,
+        stringToValue: ip6StringToValue,
+        validate: (value) => {
+            if (!isIPv6(value)) {
+                throw new ValidationError(`Invalid IPv6 address "${value}"`);
+            }
+        }
+    }, {
+        code: CODE_IP6ZONE,
+        name: 'ip6zone',
+        size: V
+    }, {
+        code: CODE_IPCIDR,
+        name: 'ipcidr',
+        size: 8,
+        bytesToValue: bytesToString('base10'),
+        valueToBytes: stringToBytes('base10')
+    }, {
+        code: CODE_DNS,
+        name: 'dns',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_DNS4,
+        name: 'dns4',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_DNS6,
+        name: 'dns6',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_DNSADDR,
+        name: 'dnsaddr',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_SCTP,
+        name: 'sctp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_UDT,
+        name: 'udt'
+    }, {
+        code: CODE_UTP,
+        name: 'utp'
+    }, {
+        code: CODE_UNIX,
+        name: 'unix',
+        size: V,
+        path: true,
+        stringToValue: (str) => decodeURIComponent(str),
+        valueToString: (val) => encodeURIComponent(val)
+    }, {
+        code: CODE_P2P,
+        name: 'p2p',
+        aliases: ['ipfs'],
+        size: V,
+        bytesToValue: bytesToString('base58btc'),
+        valueToBytes: (val) => {
+            if (val.startsWith('Q') || val.startsWith('1')) {
+                return stringToBytes('base58btc')(val);
+            }
+            return CID.parse(val).multihash.bytes;
+        }
+    }, {
+        code: CODE_ONION,
+        name: 'onion',
+        size: 96,
+        bytesToValue: bytes2onion,
+        valueToBytes: onion2bytes
+    }, {
+        code: CODE_ONION3,
+        name: 'onion3',
+        size: 296,
+        bytesToValue: bytes2onion,
+        valueToBytes: onion32bytes
+    }, {
+        code: CODE_GARLIC64,
+        name: 'garlic64',
+        size: V
+    }, {
+        code: CODE_GARLIC32,
+        name: 'garlic32',
+        size: V
+    }, {
+        code: CODE_TLS,
+        name: 'tls'
+    }, {
+        code: CODE_SNI,
+        name: 'sni',
+        size: V
+    }, {
+        code: CODE_NOISE,
+        name: 'noise'
+    }, {
+        code: CODE_QUIC,
+        name: 'quic'
+    }, {
+        code: CODE_QUIC_V1,
+        name: 'quic-v1'
+    }, {
+        code: CODE_WEBTRANSPORT,
+        name: 'webtransport'
+    }, {
+        code: CODE_CERTHASH,
+        name: 'certhash',
+        size: V,
+        bytesToValue: bytes2mb(base64url),
+        valueToBytes: mb2bytes
+    }, {
+        code: CODE_HTTP,
+        name: 'http'
+    }, {
+        code: CODE_HTTP_PATH,
+        name: 'http-path',
+        size: V,
+        stringToValue: (str) => `/${decodeURIComponent(str)}`,
+        valueToString: (val) => encodeURIComponent(val.substring(1))
+    }, {
+        code: CODE_HTTPS,
+        name: 'https'
+    }, {
+        code: CODE_WS,
+        name: 'ws'
+    }, {
+        code: CODE_WSS,
+        name: 'wss'
+    }, {
+        code: CODE_P2P_WEBSOCKET_STAR,
+        name: 'p2p-websocket-star'
+    }, {
+        code: CODE_P2P_STARDUST,
+        name: 'p2p-stardust'
+    }, {
+        code: CODE_P2P_WEBRTC_STAR,
+        name: 'p2p-webrtc-star'
+    }, {
+        code: CODE_P2P_WEBRTC_DIRECT,
+        name: 'p2p-webrtc-direct'
+    }, {
+        code: CODE_WEBRTC_DIRECT,
+        name: 'webrtc-direct'
+    }, {
+        code: CODE_WEBRTC,
+        name: 'webrtc'
+    }, {
+        code: CODE_P2P_CIRCUIT,
+        name: 'p2p-circuit'
+    }, {
+        code: CODE_MEMORY,
+        name: 'memory',
+        size: V
+    }];
+codecs.forEach(codec => {
+    registry.addProtocol(codec);
+});
+
+export { V, registry };

package/bundle/node_modules/@multiformats/multiaddr/dist/src/utils.js

@@ -0,0 +1,191 @@
+import { isIPv4 } from '../../../../@chainsafe/is-ip/lib/is-ip.js';
+import { base32 } from '../../../../multiformats/dist/src/bases/base32.js';
+import { bases } from '../../../../multiformats/dist/src/basics.js';
+import { concat } from '../../../../uint8arrays/dist/src/concat.js';
+import { fromString } from '../../../../uint8arrays/dist/src/from-string.js';
+import { toString } from '../../../../uint8arrays/dist/src/to-string.js';
+import { InvalidMultiaddrError } from './errors.js';
+
+function bytesToString(base) {
+    return (buf) => {
+        return toString(buf, base);
+    };
+}
+function stringToBytes(base) {
+    return (buf) => {
+        return fromString(buf, base);
+    };
+}
+function bytes2port(buf) {
+    const view = new DataView(buf.buffer);
+    return view.getUint16(buf.byteOffset).toString();
+}
+function port2bytes(port) {
+    const buf = new ArrayBuffer(2);
+    const view = new DataView(buf);
+    view.setUint16(0, typeof port === 'string' ? parseInt(port) : port);
+    return new Uint8Array(buf);
+}
+function onion2bytes(str) {
+    const addr = str.split(':');
+    if (addr.length !== 2) {
+        throw new Error(`failed to parse onion addr: ["'${addr.join('", "')}'"]' does not contain a port number`);
+    }
+    if (addr[0].length !== 16) {
+        throw new Error(`failed to parse onion addr: ${addr[0]} not a Tor onion address.`);
+    }
+    // onion addresses do not include the multibase prefix, add it before decoding
+    const buf = fromString(addr[0], 'base32');
+    // onion port number
+    const port = parseInt(addr[1], 10);
+    if (port < 1 || port > 65536) {
+        throw new Error('Port number is not in range(1, 65536)');
+    }
+    const portBuf = port2bytes(port);
+    return concat([buf, portBuf], buf.length + portBuf.length);
+}
+function onion32bytes(str) {
+    const addr = str.split(':');
+    if (addr.length !== 2) {
+        throw new Error(`failed to parse onion addr: ["'${addr.join('", "')}'"]' does not contain a port number`);
+    }
+    if (addr[0].length !== 56) {
+        throw new Error(`failed to parse onion addr: ${addr[0]} not a Tor onion3 address.`);
+    }
+    // onion addresses do not include the multibase prefix, add it before decoding
+    const buf = base32.decode(`b${addr[0]}`);
+    // onion port number
+    const port = parseInt(addr[1], 10);
+    if (port < 1 || port > 65536) {
+        throw new Error('Port number is not in range(1, 65536)');
+    }
+    const portBuf = port2bytes(port);
+    return concat([buf, portBuf], buf.length + portBuf.length);
+}
+function bytes2onion(buf) {
+    const addrBytes = buf.subarray(0, buf.length - 2);
+    const portBytes = buf.subarray(buf.length - 2);
+    const addr = toString(addrBytes, 'base32');
+    const port = bytes2port(portBytes);
+    return `${addr}:${port}`;
+}
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L7
+// but with buf/offset args removed because we don't use them
+const ip4ToBytes = function (ip) {
+    ip = ip.toString().trim();
+    const bytes = new Uint8Array(4);
+    ip.split(/\./g).forEach((byte, index) => {
+        const value = parseInt(byte, 10);
+        if (isNaN(value) || value < 0 || value > 0xff) {
+            throw new InvalidMultiaddrError('Invalid byte value in IP address');
+        }
+        bytes[index] = value;
+    });
+    return bytes;
+};
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L7
+// but with buf/offset args removed because we don't use them
+const ip6ToBytes = function (ip) {
+    let offset = 0;
+    ip = ip.toString().trim();
+    const sections = ip.split(':', 8);
+    let i;
+    for (i = 0; i < sections.length; i++) {
+        const isv4 = isIPv4(sections[i]);
+        let v4Buffer;
+        if (isv4) {
+            v4Buffer = ip4ToBytes(sections[i]);
+            sections[i] = toString(v4Buffer.subarray(0, 2), 'base16');
+        }
+        if (v4Buffer != null && ++i < 8) {
+            sections.splice(i, 0, toString(v4Buffer.subarray(2, 4), 'base16'));
+        }
+    }
+    if (sections[0] === '') {
+        while (sections.length < 8) {
+            sections.unshift('0');
+        }
+    }
+    else if (sections[sections.length - 1] === '') {
+        while (sections.length < 8) {
+            sections.push('0');
+        }
+    }
+    else if (sections.length < 8) {
+        for (i = 0; i < sections.length && sections[i] !== ''; i++) { }
+        const argv = [i, 1];
+        for (i = 9 - sections.length; i > 0; i--) {
+            argv.push('0');
+        }
+        sections.splice.apply(sections, argv);
+    }
+    const bytes = new Uint8Array(offset + 16);
+    for (i = 0; i < sections.length; i++) {
+        if (sections[i] === '') {
+            sections[i] = '0';
+        }
+        const word = parseInt(sections[i], 16);
+        if (isNaN(word) || word < 0 || word > 0xffff) {
+            throw new InvalidMultiaddrError('Invalid byte value in IP address');
+        }
+        bytes[offset++] = (word >> 8) & 0xff;
+        bytes[offset++] = word & 0xff;
+    }
+    return bytes;
+};
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L63
+const ip4ToString = function (buf) {
+    if (buf.byteLength !== 4) {
+        throw new InvalidMultiaddrError('IPv4 address was incorrect length');
+    }
+    const result = [];
+    for (let i = 0; i < buf.byteLength; i++) {
+        result.push(buf[i]);
+    }
+    return result.join('.');
+};
+const ip6ToString = function (buf) {
+    if (buf.byteLength !== 16) {
+        throw new InvalidMultiaddrError('IPv6 address was incorrect length');
+    }
+    const result = [];
+    for (let i = 0; i < buf.byteLength; i += 2) {
+        const byte1 = buf[i];
+        const byte2 = buf[i + 1];
+        const tuple = `${byte1.toString(16).padStart(2, '0')}${byte2.toString(16).padStart(2, '0')}`;
+        result.push(tuple);
+    }
+    const ip = result.join(':');
+    try {
+        const url = new URL(`http://[${ip}]`);
+        return url.hostname.substring(1, url.hostname.length - 1);
+    }
+    catch {
+        throw new InvalidMultiaddrError(`Invalid IPv6 address "${ip}"`);
+    }
+};
+function ip6StringToValue(str) {
+    try {
+        const url = new URL(`http://[${str}]`);
+        return url.hostname.substring(1, url.hostname.length - 1);
+    }
+    catch {
+        throw new InvalidMultiaddrError(`Invalid IPv6 address "${str}"`);
+    }
+}
+const decoders = Object.values(bases).map((c) => c.decoder);
+const anybaseDecoder = (function () {
+    let acc = decoders[0].or(decoders[1]);
+    decoders.slice(2).forEach((d) => (acc = acc.or(d)));
+    return acc;
+})();
+function mb2bytes(mbstr) {
+    return anybaseDecoder.decode(mbstr);
+}
+function bytes2mb(base) {
+    return (buf) => {
+        return base.encoder.encode(buf);
+    };
+}
+
+export { bytes2mb, bytes2onion, bytes2port, bytesToString, ip4ToBytes, ip4ToString, ip6StringToValue, ip6ToBytes, ip6ToString, mb2bytes, onion2bytes, onion32bytes, port2bytes, stringToBytes };

package/bundle/node_modules/@multiformats/multiaddr/dist/src/validation.js

@@ -0,0 +1,30 @@
+import { ValidationError } from './errors.js';
+
+function integer(value) {
+    const int = parseInt(value);
+    if (int.toString() !== value) {
+        throw new ValidationError('Value must be an integer');
+    }
+}
+function positive(value) {
+    if (value < 0) {
+        throw new ValidationError('Value must be a positive integer, or zero');
+    }
+}
+function maxValue(max) {
+    return (value) => {
+        if (value > max) {
+            throw new ValidationError(`Value must be smaller than or equal to ${max}`);
+        }
+    };
+}
+function validate(...funcs) {
+    return (value) => {
+        for (const fn of funcs) {
+            fn(value);
+        }
+    };
+}
+const validatePort = validate(integer, positive, maxValue(65_535));
+
+export { integer, maxValue, positive, validate, validatePort };

package/bundle/node_modules/debug/src/browser.js

@@ -224,7 +224,7 @@ import { c as common } from './common.js';
 	function load() {
 		let r;
 		try {
-			r = exports.storage.getItem('debug');
+			r = exports.storage.getItem('debug') || exports.storage.getItem('DEBUG') ;
 		} catch (error) {
 			// Swallow
 			// XXX (@Qix-) should we be logging these?

package/bundle/node_modules/debug/src/common.js

@@ -169,7 +169,7 @@ function setup(env) {
 
 		const split = (typeof namespaces === 'string' ? namespaces : '')
 			.trim()
-			.replace(' ', ',')
+			.replace(/\s+/g, ',')
 			.split(',')
 			.filter(Boolean);
 

package/bundle/node_modules/lodash/lodash.js

@@ -4302,7 +4302,7 @@ lodash.exports;
 	        return symbolToString ? symbolToString.call(value) : '';
 	      }
 	      var result = (value + '');
-	      return (result == '0' && (1 / value) == -Infinity) ? '-0' : result;
+	      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
 	    }
 
 	    /**
@@ -6825,7 +6825,7 @@ lodash.exports;
 	        return value;
 	      }
 	      var result = (value + '');
-	      return (result == '0' && (1 / value) == -Infinity) ? '-0' : result;
+	      return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
 	    }
 
 	    /**
@@ -12167,7 +12167,7 @@ lodash.exports;
 	     * // => false
 	     */
 	    function isSafeInteger(value) {
-	      return isInteger(value) && value >= -9007199254740991 && value <= MAX_SAFE_INTEGER;
+	      return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;
 	    }
 
 	    /**
@@ -12434,7 +12434,7 @@ lodash.exports;
 	        return value === 0 ? value : 0;
 	      }
 	      value = toNumber(value);
-	      if (value === INFINITY || value === -Infinity) {
+	      if (value === INFINITY || value === -INFINITY) {
 	        var sign = (value < 0 ? -1 : 1);
 	        return sign * MAX_INTEGER;
 	      }
@@ -12603,7 +12603,7 @@ lodash.exports;
 	     */
 	    function toSafeInteger(value) {
 	      return value
-	        ? baseClamp(toInteger(value), -9007199254740991, MAX_SAFE_INTEGER)
+	        ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)
 	        : (value === 0 ? value : 0);
 	    }
 

package/bundle/node_modules/multiformats/dist/src/bases/base.js

@@ -80,7 +80,6 @@ class ComposedDecoder {
     }
 }
 function or(left, right) {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return new ComposedDecoder({
         ...(left.decoders ?? { [left.prefix]: left }),
         ...(right.decoders ?? { [right.prefix]: right })
@@ -120,12 +119,7 @@ function baseX({ name, prefix, alphabet }) {
         decode: (text) => coerce(decode(text))
     });
 }
-function decode(string, alphabet, bitsPerChar, name) {
-    // Build the character lookup table:
-    const codes = {};
-    for (let i = 0; i < alphabet.length; ++i) {
-        codes[alphabet[i]] = i;
-    }
+function decode(string, alphabetIdx, bitsPerChar, name) {
     // Count the padding bytes:
     let end = string.length;
     while (string[end - 1] === '=') {
@@ -139,7 +133,7 @@ function decode(string, alphabet, bitsPerChar, name) {
     let written = 0; // Next byte to write
     for (let i = 0; i < end; ++i) {
         // Read one character from the string:
-        const value = codes[string[i]];
+        const value = alphabetIdx[string[i]];
         if (value === undefined) {
             throw new SyntaxError(`Non-${name} character`);
         }
@@ -186,10 +180,19 @@ function encode(data, alphabet, bitsPerChar) {
     }
     return out;
 }
+function createAlphabetIdx(alphabet) {
+    // Build the character lookup table:
+    const alphabetIdx = {};
+    for (let i = 0; i < alphabet.length; ++i) {
+        alphabetIdx[alphabet[i]] = i;
+    }
+    return alphabetIdx;
+}
 /**
  * RFC4648 Factory
  */
 function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+    const alphabetIdx = createAlphabetIdx(alphabet);
     return from({
         prefix,
         name,
@@ -197,7 +200,7 @@ function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
             return encode(input, alphabet, bitsPerChar);
         },
         decode(input) {
-            return decode(input, alphabet, bitsPerChar, name);
+            return decode(input, alphabetIdx, bitsPerChar, name);
         }
     });
 }

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

@@ -1,8 +1,24 @@
+function equals(aa, bb) {
+    if (aa === bb) {
+        return true;
+    }
+    if (aa.byteLength !== bb.byteLength) {
+        return false;
+    }
+    for (let ii = 0; ii < aa.byteLength; ii++) {
+        if (aa[ii] !== bb[ii]) {
+            return false;
+        }
+    }
+    return true;
+}
 function coerce(o) {
-    if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')
+    if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array') {
         return o;
-    if (o instanceof ArrayBuffer)
+    }
+    if (o instanceof ArrayBuffer) {
         return new Uint8Array(o);
+    }
     if (ArrayBuffer.isView(o)) {
         return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
     }
@@ -15,4 +31,4 @@ function toString(b) {
     return new TextDecoder().decode(b);
 }
 
-export { coerce, fromString, toString };
+export { coerce, equals, fromString, toString };