@waku/rln 0.1.6-f911bf8.0 → 0.1.7-7a9850d.0

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 };