@waku/message-encryption 0.0.24 → 0.0.26-070b625.0

package/bundle/{symmetric-CXVjdTdV.js → symmetric-qyNI8P98.js}

@@ -1036,514 +1036,396 @@ Object.defineProperties(utils, {
     },
 });
 
-/**
- * To guarantee Uint8Array semantics, convert nodejs Buffers
- * into vanilla Uint8Arrays
- */
-function asUint8Array(buf) {
-    if (globalThis.Buffer != null) {
-        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+function coerce(o) {
+    if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')
+        return o;
+    if (o instanceof ArrayBuffer)
+        return new Uint8Array(o);
+    if (ArrayBuffer.isView(o)) {
+        return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
     }
-    return buf;
+    throw new Error('Unknown type, must be binary type');
+}
+function fromString$1(str) {
+    return new TextEncoder().encode(str);
+}
+function toString(b) {
+    return new TextDecoder().decode(b);
 }
 
+/* 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.
-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
-  function encode (source) {
-    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++;
+/**
+ * @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);
+        var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
+        var b58 = new Uint8Array(size);
         // Process the bytes.
-    while (pbegin !== pend) {
-      var carry = source[pbegin];
+        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++;
-    }
+            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++;
-    }
+        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
-  }
-  function decodeUnsafe (source) {
-    if (typeof source !== 'string') { throw new TypeError('Expected String') }
-    if (source.length === 0) { return new Uint8Array() }
-    var psz = 0;
+        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 }
+        if (source[psz] === ' ') {
+            return;
+        }
         // Skip and count leading '1's.
-    var zeroes = 0;
-    var length = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
+        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);
+        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]) {
+        while (source[psz]) {
             // Decode character
-      var carry = BASE_MAP[source.charCodeAt(psz)];
+            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++;
-    }
+            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 }
+        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
-  }
-  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 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;
 
-/**
- * @param {ArrayBufferView|ArrayBuffer|Uint8Array} o
- * @returns {Uint8Array}
- */
-const coerce = o => {
-  if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array') return o
-  if (o instanceof ArrayBuffer) return new Uint8Array(o)
-  if (ArrayBuffer.isView(o)) {
-    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength)
-  }
-  throw new Error('Unknown type, must be binary type')
-};
-
-/**
- * @param {string} str
- * @returns {Uint8Array}
- */
-const fromString$1 = str => (new TextEncoder()).encode(str);
-
-/**
- * @param {Uint8Array} b
- * @returns {string}
- */
-const toString = b => (new TextDecoder()).decode(b);
-
 /**
  * Class represents both BaseEncoder and MultibaseEncoder meaning it
  * can be used to encode to multibase or base encode without multibase
  * prefix.
- *
- * @class
- * @template {string} Base
- * @template {string} Prefix
- * @implements {API.MultibaseEncoder<Prefix>}
- * @implements {API.BaseEncoder}
  */
 class Encoder {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(bytes:Uint8Array) => string} baseEncode
-   */
-  constructor (name, prefix, baseEncode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-  }
-
-  /**
-   * @param {Uint8Array} bytes
-   * @returns {API.Multibase<Prefix>}
-   */
-  encode (bytes) {
-    if (bytes instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes)}`
-    } else {
-      throw Error('Unknown type, must be binary type')
-    }
-  }
+    name;
+    prefix;
+    baseEncode;
+    constructor(name, prefix, baseEncode) {
+        this.name = name;
+        this.prefix = prefix;
+        this.baseEncode = baseEncode;
+    }
+    encode(bytes) {
+        if (bytes instanceof Uint8Array) {
+            return `${this.prefix}${this.baseEncode(bytes)}`;
+        }
+        else {
+            throw Error('Unknown type, must be binary type');
+        }
+    }
 }
-
-/**
- * @template {string} Prefix
- */
 /**
  * Class represents both BaseDecoder and MultibaseDecoder so it could be used
  * to decode multibases (with matching prefix) or just base decode strings
  * with corresponding base encoding.
- *
- * @class
- * @template {string} Base
- * @template {string} Prefix
- * @implements {API.MultibaseDecoder<Prefix>}
- * @implements {API.UnibaseDecoder<Prefix>}
- * @implements {API.BaseDecoder}
  */
 class Decoder {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(text:string) => Uint8Array} baseDecode
-   */
-  constructor (name, prefix, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    /* c8 ignore next 3 */
-    if (prefix.codePointAt(0) === undefined) {
-      throw new Error('Invalid prefix character')
-    }
-    /** @private */
-    this.prefixCodePoint = /** @type {number} */ (prefix.codePointAt(0));
-    this.baseDecode = baseDecode;
-  }
-
-  /**
-   * @param {string} text
-   */
-  decode (text) {
-    if (typeof text === 'string') {
-      if (text.codePointAt(0) !== this.prefixCodePoint) {
-        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`)
-      }
-      return this.baseDecode(text.slice(this.prefix.length))
-    } else {
-      throw Error('Can only multibase decode strings')
-    }
-  }
-
-  /**
-   * @template {string} OtherPrefix
-   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-   */
-  or (decoder) {
-    return or(this, decoder)
-  }
+    name;
+    prefix;
+    baseDecode;
+    prefixCodePoint;
+    constructor(name, prefix, baseDecode) {
+        this.name = name;
+        this.prefix = prefix;
+        /* c8 ignore next 3 */
+        if (prefix.codePointAt(0) === undefined) {
+            throw new Error('Invalid prefix character');
+        }
+        this.prefixCodePoint = prefix.codePointAt(0);
+        this.baseDecode = baseDecode;
+    }
+    decode(text) {
+        if (typeof text === 'string') {
+            if (text.codePointAt(0) !== this.prefixCodePoint) {
+                throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+            }
+            return this.baseDecode(text.slice(this.prefix.length));
+        }
+        else {
+            throw Error('Can only multibase decode strings');
+        }
+    }
+    or(decoder) {
+        return or(this, decoder);
+    }
 }
-
-/**
- * @template {string} Prefix
- * @typedef {Record<Prefix, API.UnibaseDecoder<Prefix>>} Decoders
- */
-
-/**
- * @template {string} Prefix
- * @implements {API.MultibaseDecoder<Prefix>}
- * @implements {API.CombobaseDecoder<Prefix>}
- */
 class ComposedDecoder {
-  /**
-   * @param {Decoders<Prefix>} decoders
-   */
-  constructor (decoders) {
-    this.decoders = decoders;
-  }
-
-  /**
-   * @template {string} OtherPrefix
-   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-   */
-  or (decoder) {
-    return or(this, decoder)
-  }
-
-  /**
-   * @param {string} input
-   * @returns {Uint8Array}
-   */
-  decode (input) {
-    const prefix = /** @type {Prefix} */ (input[0]);
-    const decoder = this.decoders[prefix];
-    if (decoder) {
-      return decoder.decode(input)
-    } else {
-      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`)
-    }
-  }
+    decoders;
+    constructor(decoders) {
+        this.decoders = decoders;
+    }
+    or(decoder) {
+        return or(this, decoder);
+    }
+    decode(input) {
+        const prefix = input[0];
+        const decoder = this.decoders[prefix];
+        if (decoder != null) {
+            return decoder.decode(input);
+        }
+        else {
+            throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+        }
+    }
+}
+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 })
+    });
 }
-
-/**
- * @template {string} L
- * @template {string} R
- * @param {API.UnibaseDecoder<L>|API.CombobaseDecoder<L>} left
- * @param {API.UnibaseDecoder<R>|API.CombobaseDecoder<R>} right
- * @returns {ComposedDecoder<L|R>}
- */
-const or = (left, right) => new ComposedDecoder(/** @type {Decoders<L|R>} */({
-  ...(left.decoders || { [/** @type API.UnibaseDecoder<L> */(left).prefix]: left }),
-  ...(right.decoders || { [/** @type API.UnibaseDecoder<R> */(right).prefix]: right })
-}));
-
-/**
- * @class
- * @template {string} Base
- * @template {string} Prefix
- * @implements {API.MultibaseCodec<Prefix>}
- * @implements {API.MultibaseEncoder<Prefix>}
- * @implements {API.MultibaseDecoder<Prefix>}
- * @implements {API.BaseCodec}
- * @implements {API.BaseEncoder}
- * @implements {API.BaseDecoder}
- */
 class Codec {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(bytes:Uint8Array) => string} baseEncode
-   * @param {(text:string) => Uint8Array} baseDecode
-   */
-  constructor (name, prefix, baseEncode, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-    this.baseDecode = baseDecode;
-    this.encoder = new Encoder(name, prefix, baseEncode);
-    this.decoder = new Decoder(name, prefix, baseDecode);
-  }
-
-  /**
-   * @param {Uint8Array} input
-   */
-  encode (input) {
-    return this.encoder.encode(input)
-  }
-
-  /**
-   * @param {string} input
-   */
-  decode (input) {
-    return this.decoder.decode(input)
-  }
+    name;
+    prefix;
+    baseEncode;
+    baseDecode;
+    encoder;
+    decoder;
+    constructor(name, prefix, baseEncode, baseDecode) {
+        this.name = name;
+        this.prefix = prefix;
+        this.baseEncode = baseEncode;
+        this.baseDecode = baseDecode;
+        this.encoder = new Encoder(name, prefix, baseEncode);
+        this.decoder = new Decoder(name, prefix, baseDecode);
+    }
+    encode(input) {
+        return this.encoder.encode(input);
+    }
+    decode(input) {
+        return this.decoder.decode(input);
+    }
+}
+function from({ name, prefix, encode, decode }) {
+    return new Codec(name, prefix, encode, decode);
+}
+function baseX({ name, prefix, alphabet }) {
+    const { encode, decode } = _brrp__multiformats_scope_baseX(alphabet, name);
+    return from({
+        prefix,
+        name,
+        encode,
+        decode: (text) => coerce(decode(text))
+    });
+}
+function decode$1(string, alphabet, bitsPerChar, name) {
+    // Build the character lookup table:
+    const codes = {};
+    for (let i = 0; i < alphabet.length; ++i) {
+        codes[alphabet[i]] = i;
+    }
+    // Count the padding bytes:
+    let end = string.length;
+    while (string[end - 1] === '=') {
+        --end;
+    }
+    // Allocate the output:
+    const out = new Uint8Array((end * bitsPerChar / 8) | 0);
+    // Parse the data:
+    let bits = 0; // Number of bits currently in the buffer
+    let buffer = 0; // Bits waiting to be written out, MSB first
+    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]];
+        if (value === undefined) {
+            throw new SyntaxError(`Non-${name} character`);
+        }
+        // Append the bits to the buffer:
+        buffer = (buffer << bitsPerChar) | value;
+        bits += bitsPerChar;
+        // Write out some bits if the buffer has a byte's worth:
+        if (bits >= 8) {
+            bits -= 8;
+            out[written++] = 0xff & (buffer >> bits);
+        }
+    }
+    // Verify that we have received just enough bits:
+    if (bits >= bitsPerChar || (0xff & (buffer << (8 - bits))) !== 0) {
+        throw new SyntaxError('Unexpected end of data');
+    }
+    return out;
+}
+function encode$1(data, alphabet, bitsPerChar) {
+    const pad = alphabet[alphabet.length - 1] === '=';
+    const mask = (1 << bitsPerChar) - 1;
+    let out = '';
+    let bits = 0; // Number of bits currently in the buffer
+    let buffer = 0; // Bits waiting to be written out, MSB first
+    for (let i = 0; i < data.length; ++i) {
+        // Slurp data into the buffer:
+        buffer = (buffer << 8) | data[i];
+        bits += 8;
+        // Write out as much as we can:
+        while (bits > bitsPerChar) {
+            bits -= bitsPerChar;
+            out += alphabet[mask & (buffer >> bits)];
+        }
+    }
+    // Partial character:
+    if (bits !== 0) {
+        out += alphabet[mask & (buffer << (bitsPerChar - bits))];
+    }
+    // Add padding characters until we hit a byte boundary:
+    if (pad) {
+        while (((out.length * bitsPerChar) & 7) !== 0) {
+            out += '=';
+        }
+    }
+    return out;
 }
-
-/**
- * @template {string} Base
- * @template {string} Prefix
- * @param {object} options
- * @param {Base} options.name
- * @param {Prefix} options.prefix
- * @param {(bytes:Uint8Array) => string} options.encode
- * @param {(input:string) => Uint8Array} options.decode
- * @returns {Codec<Base, Prefix>}
- */
-const from = ({ name, prefix, encode, decode }) =>
-  new Codec(name, prefix, encode, decode);
-
-/**
- * @template {string} Base
- * @template {string} Prefix
- * @param {object} options
- * @param {Base} options.name
- * @param {Prefix} options.prefix
- * @param {string} options.alphabet
- * @returns {Codec<Base, Prefix>}
- */
-const baseX = ({ prefix, name, alphabet }) => {
-  const { encode, decode } = _brrp__multiformats_scope_baseX(alphabet, name);
-  return from({
-    prefix,
-    name,
-    encode,
-    /**
-     * @param {string} text
-     */
-    decode: text => coerce(decode(text))
-  })
-};
-
-/**
- * @param {string} string
- * @param {string} alphabet
- * @param {number} bitsPerChar
- * @param {string} name
- * @returns {Uint8Array}
- */
-const decode$1 = (string, alphabet, bitsPerChar, name) => {
-  // Build the character lookup table:
-  /** @type {Record<string, number>} */
-  const codes = {};
-  for (let i = 0; i < alphabet.length; ++i) {
-    codes[alphabet[i]] = i;
-  }
-
-  // Count the padding bytes:
-  let end = string.length;
-  while (string[end - 1] === '=') {
-    --end;
-  }
-
-  // Allocate the output:
-  const out = new Uint8Array((end * bitsPerChar / 8) | 0);
-
-  // Parse the data:
-  let bits = 0; // Number of bits currently in the buffer
-  let buffer = 0; // Bits waiting to be written out, MSB first
-  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]];
-    if (value === undefined) {
-      throw new SyntaxError(`Non-${name} character`)
-    }
-
-    // Append the bits to the buffer:
-    buffer = (buffer << bitsPerChar) | value;
-    bits += bitsPerChar;
-
-    // Write out some bits if the buffer has a byte's worth:
-    if (bits >= 8) {
-      bits -= 8;
-      out[written++] = 0xff & (buffer >> bits);
-    }
-  }
-
-  // Verify that we have received just enough bits:
-  if (bits >= bitsPerChar || 0xff & (buffer << (8 - bits))) {
-    throw new SyntaxError('Unexpected end of data')
-  }
-
-  return out
-};
-
-/**
- * @param {Uint8Array} data
- * @param {string} alphabet
- * @param {number} bitsPerChar
- * @returns {string}
- */
-const encode$1 = (data, alphabet, bitsPerChar) => {
-  const pad = alphabet[alphabet.length - 1] === '=';
-  const mask = (1 << bitsPerChar) - 1;
-  let out = '';
-
-  let bits = 0; // Number of bits currently in the buffer
-  let buffer = 0; // Bits waiting to be written out, MSB first
-  for (let i = 0; i < data.length; ++i) {
-    // Slurp data into the buffer:
-    buffer = (buffer << 8) | data[i];
-    bits += 8;
-
-    // Write out as much as we can:
-    while (bits > bitsPerChar) {
-      bits -= bitsPerChar;
-      out += alphabet[mask & (buffer >> bits)];
-    }
-  }
-
-  // Partial character:
-  if (bits) {
-    out += alphabet[mask & (buffer << (bitsPerChar - bits))];
-  }
-
-  // Add padding characters until we hit a byte boundary:
-  if (pad) {
-    while ((out.length * bitsPerChar) & 7) {
-      out += '=';
-    }
-  }
-
-  return out
-};
-
 /**
  * RFC4648 Factory
- *
- * @template {string} Base
- * @template {string} Prefix
- * @param {object} options
- * @param {Base} options.name
- * @param {Prefix} options.prefix
- * @param {string} options.alphabet
- * @param {number} options.bitsPerChar
  */
-const rfc4648 = ({ name, prefix, bitsPerChar, alphabet }) => {
-  return from({
-    prefix,
-    name,
-    encode (input) {
-      return encode$1(input, alphabet, bitsPerChar)
-    },
-    decode (input) {
-      return decode$1(input, alphabet, bitsPerChar, name)
-    }
-  })
-};
+function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+    return from({
+        prefix,
+        name,
+        encode(input) {
+            return encode$1(input, alphabet, bitsPerChar);
+        },
+        decode(input) {
+            return decode$1(input, alphabet, bitsPerChar, name);
+        }
+    });
+}
 
 const base10 = baseX({
-  prefix: '9',
-  name: 'base10',
-  alphabet: '0123456789'
+    prefix: '9',
+    name: 'base10',
+    alphabet: '0123456789'
 });
 
 var base10$1 = /*#__PURE__*/Object.freeze({
@@ -1551,21 +1433,17 @@ var base10$1 = /*#__PURE__*/Object.freeze({
     base10: base10
 });
 
-// @ts-check
-
-
 const base16 = rfc4648({
-  prefix: 'f',
-  name: 'base16',
-  alphabet: '0123456789abcdef',
-  bitsPerChar: 4
+    prefix: 'f',
+    name: 'base16',
+    alphabet: '0123456789abcdef',
+    bitsPerChar: 4
 });
-
 const base16upper = rfc4648({
-  prefix: 'F',
-  name: 'base16upper',
-  alphabet: '0123456789ABCDEF',
-  bitsPerChar: 4
+    prefix: 'F',
+    name: 'base16upper',
+    alphabet: '0123456789ABCDEF',
+    bitsPerChar: 4
 });
 
 var base16$1 = /*#__PURE__*/Object.freeze({
@@ -1574,14 +1452,11 @@ var base16$1 = /*#__PURE__*/Object.freeze({
     base16upper: base16upper
 });
 
-// @ts-check
-
-
 const base2 = rfc4648({
-  prefix: '0',
-  name: 'base2',
-  alphabet: '01',
-  bitsPerChar: 1
+    prefix: '0',
+    name: 'base2',
+    alphabet: '01',
+    bitsPerChar: 1
 });
 
 var base2$1 = /*#__PURE__*/Object.freeze({
@@ -1590,41 +1465,30 @@ var base2$1 = /*#__PURE__*/Object.freeze({
 });
 
 const alphabet = Array.from('🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂');
-const alphabetBytesToChars = /** @type {string[]} */ (alphabet.reduce((p, c, i) => { p[i] = c; return p }, /** @type {string[]} */([])));
-const alphabetCharsToBytes = /** @type {number[]} */ (alphabet.reduce((p, c, i) => { p[/** @type {number} */ (c.codePointAt(0))] = i; return p }, /** @type {number[]} */([])));
-
-/**
- * @param {Uint8Array} data
- * @returns {string}
- */
-function encode (data) {
-  return data.reduce((p, c) => {
-    p += alphabetBytesToChars[c];
-    return p
-  }, '')
-}
-
-/**
- * @param {string} str
- * @returns {Uint8Array}
- */
-function decode (str) {
-  const byts = [];
-  for (const char of str) {
-    const byt = alphabetCharsToBytes[/** @type {number} */ (char.codePointAt(0))];
-    if (byt === undefined) {
-      throw new Error(`Non-base256emoji character: ${char}`)
+const alphabetBytesToChars = (alphabet.reduce((p, c, i) => { p[i] = c; return p; }, ([])));
+const alphabetCharsToBytes = (alphabet.reduce((p, c, i) => { p[c.codePointAt(0)] = i; return p; }, ([])));
+function encode(data) {
+    return data.reduce((p, c) => {
+        p += alphabetBytesToChars[c];
+        return p;
+    }, '');
+}
+function decode(str) {
+    const byts = [];
+    for (const char of str) {
+        const byt = alphabetCharsToBytes[char.codePointAt(0)];
+        if (byt === undefined) {
+            throw new Error(`Non-base256emoji character: ${char}`);
+        }
+        byts.push(byt);
     }
-    byts.push(byt);
-  }
-  return new Uint8Array(byts)
+    return new Uint8Array(byts);
 }
-
 const base256emoji = from({
-  prefix: '🚀',
-  name: 'base256emoji',
-  encode,
-  decode
+    prefix: '🚀',
+    name: 'base256emoji',
+    encode,
+    decode
 });
 
 var base256emoji$1 = /*#__PURE__*/Object.freeze({
@@ -1633,66 +1497,58 @@ var base256emoji$1 = /*#__PURE__*/Object.freeze({
 });
 
 const base32 = rfc4648({
-  prefix: 'b',
-  name: 'base32',
-  alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
-  bitsPerChar: 5
+    prefix: 'b',
+    name: 'base32',
+    alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
+    bitsPerChar: 5
 });
-
 const base32upper = rfc4648({
-  prefix: 'B',
-  name: 'base32upper',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
-  bitsPerChar: 5
+    prefix: 'B',
+    name: 'base32upper',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+    bitsPerChar: 5
 });
-
 const base32pad = rfc4648({
-  prefix: 'c',
-  name: 'base32pad',
-  alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
-  bitsPerChar: 5
+    prefix: 'c',
+    name: 'base32pad',
+    alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
+    bitsPerChar: 5
 });
-
 const base32padupper = rfc4648({
-  prefix: 'C',
-  name: 'base32padupper',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
-  bitsPerChar: 5
+    prefix: 'C',
+    name: 'base32padupper',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
+    bitsPerChar: 5
 });
-
 const base32hex = rfc4648({
-  prefix: 'v',
-  name: 'base32hex',
-  alphabet: '0123456789abcdefghijklmnopqrstuv',
-  bitsPerChar: 5
+    prefix: 'v',
+    name: 'base32hex',
+    alphabet: '0123456789abcdefghijklmnopqrstuv',
+    bitsPerChar: 5
 });
-
 const base32hexupper = rfc4648({
-  prefix: 'V',
-  name: 'base32hexupper',
-  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
-  bitsPerChar: 5
+    prefix: 'V',
+    name: 'base32hexupper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
+    bitsPerChar: 5
 });
-
 const base32hexpad = rfc4648({
-  prefix: 't',
-  name: 'base32hexpad',
-  alphabet: '0123456789abcdefghijklmnopqrstuv=',
-  bitsPerChar: 5
+    prefix: 't',
+    name: 'base32hexpad',
+    alphabet: '0123456789abcdefghijklmnopqrstuv=',
+    bitsPerChar: 5
 });
-
 const base32hexpadupper = rfc4648({
-  prefix: 'T',
-  name: 'base32hexpadupper',
-  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
-  bitsPerChar: 5
+    prefix: 'T',
+    name: 'base32hexpadupper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
+    bitsPerChar: 5
 });
-
 const base32z = rfc4648({
-  prefix: 'h',
-  name: 'base32z',
-  alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
-  bitsPerChar: 5
+    prefix: 'h',
+    name: 'base32z',
+    alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
+    bitsPerChar: 5
 });
 
 var base32$1 = /*#__PURE__*/Object.freeze({
@@ -1709,15 +1565,14 @@ var base32$1 = /*#__PURE__*/Object.freeze({
 });
 
 const base36 = baseX({
-  prefix: 'k',
-  name: 'base36',
-  alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
+    prefix: 'k',
+    name: 'base36',
+    alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
 });
-
 const base36upper = baseX({
-  prefix: 'K',
-  name: 'base36upper',
-  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    prefix: 'K',
+    name: 'base36upper',
+    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 });
 
 var base36$1 = /*#__PURE__*/Object.freeze({
@@ -1727,15 +1582,14 @@ var base36$1 = /*#__PURE__*/Object.freeze({
 });
 
 const base58btc = baseX({
-  name: 'base58btc',
-  prefix: 'z',
-  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+    name: 'base58btc',
+    prefix: 'z',
+    alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 });
-
 const base58flickr = baseX({
-  name: 'base58flickr',
-  prefix: 'Z',
-  alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+    name: 'base58flickr',
+    prefix: 'Z',
+    alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
 });
 
 var base58 = /*#__PURE__*/Object.freeze({
@@ -1744,35 +1598,29 @@ var base58 = /*#__PURE__*/Object.freeze({
     base58flickr: base58flickr
 });
 
-// @ts-check
-
-
 const base64 = rfc4648({
-  prefix: 'm',
-  name: 'base64',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
-  bitsPerChar: 6
+    prefix: 'm',
+    name: 'base64',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+    bitsPerChar: 6
 });
-
 const base64pad = rfc4648({
-  prefix: 'M',
-  name: 'base64pad',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
-  bitsPerChar: 6
+    prefix: 'M',
+    name: 'base64pad',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+    bitsPerChar: 6
 });
-
 const base64url = rfc4648({
-  prefix: 'u',
-  name: 'base64url',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
-  bitsPerChar: 6
+    prefix: 'u',
+    name: 'base64url',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+    bitsPerChar: 6
 });
-
 const base64urlpad = rfc4648({
-  prefix: 'U',
-  name: 'base64urlpad',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
-  bitsPerChar: 6
+    prefix: 'U',
+    name: 'base64urlpad',
+    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
+    bitsPerChar: 6
 });
 
 var base64$1 = /*#__PURE__*/Object.freeze({
@@ -1783,14 +1631,11 @@ var base64$1 = /*#__PURE__*/Object.freeze({
     base64urlpad: base64urlpad
 });
 
-// @ts-check
-
-
 const base8 = rfc4648({
-  prefix: '7',
-  name: 'base8',
-  alphabet: '01234567',
-  bitsPerChar: 3
+    prefix: '7',
+    name: 'base8',
+    alphabet: '01234567',
+    bitsPerChar: 3
 });
 
 var base8$1 = /*#__PURE__*/Object.freeze({
@@ -1798,14 +1643,11 @@ var base8$1 = /*#__PURE__*/Object.freeze({
     base8: base8
 });
 
-// @ts-check
-
-
 const identity = from({
-  prefix: '\x00',
-  name: 'identity',
-  encode: (buf) => toString(buf),
-  decode: (str) => fromString$1(str)
+    prefix: '\x00',
+    name: 'identity',
+    encode: (buf) => toString(buf),
+    decode: (str) => fromString$1(str)
 });
 
 var identityBase = /*#__PURE__*/Object.freeze({
@@ -1813,30 +1655,24 @@ var identityBase = /*#__PURE__*/Object.freeze({
     identity: identity
 });
 
-// @ts-check
-
-/**
- * @template T
- * @typedef {import('./interface.js').ByteView<T>} ByteView
- */
-
 new TextEncoder();
 new TextDecoder();
 
-// @ts-check
-
-
 const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$1, ...base32$1, ...base36$1, ...base58, ...base64$1, ...base256emoji$1 };
 
+/**
+ * Returns a `Uint8Array` of the requested size. Referenced memory will
+ * be initialized to 0.
+ */
+function alloc(size = 0) {
+    return new Uint8Array(size);
+}
 /**
  * Where possible returns a Uint8Array of the requested size that references
  * uninitialized memory. Only use if you are certain you will immediately
  * overwrite every value in the returned `Uint8Array`.
  */
 function allocUnsafe(size = 0) {
-    if (globalThis.Buffer?.allocUnsafe != null) {
-        return asUint8Array(globalThis.Buffer.allocUnsafe(size));
-    }
     return new Uint8Array(size);
 }
 
@@ -1897,9 +1733,6 @@ function fromString(string, encoding = 'utf8') {
     if (base == null) {
         throw new Error(`Unsupported encoding "${encoding}"`);
     }
-    if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
-        return asUint8Array(globalThis.Buffer.from(string, 'utf-8'));
-    }
     // add multibase prefix
     return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
 }
@@ -1945,7 +1778,7 @@ var sha3$1 = {exports: {}};
 /**
  * [js-sha3]{@link https://github.com/emn178/js-sha3}
  *
- * @version 0.9.2
+ * @version 0.9.3
  * @author Chen, Yi-Cyuan [emn178@gmail.com]
  * @copyright Chen, Yi-Cyuan 2015-2023
  * @license MIT
@@ -2025,6 +1858,14 @@ var sha3$1 = {exports: {}};
 	    return formatMessage(message)[0].length === 0;
 	  };
 
+	  var cloneArray = function (array) {
+	    var newArray = [];
+	    for (var i = 0; i < array.length; ++i) {
+	      newArray[i] = array[i];
+	    }
+	    return newArray;
+	  };
+
 	  var createOutputMethod = function (bits, padding, outputType) {
 	    return function (message) {
 	      return new Keccak(bits, padding, bits).update(message)[outputType]();
@@ -2304,6 +2145,7 @@ var sha3$1 = {exports: {}};
 	          HEX_CHARS[(block >> 28) & 0x0F] + HEX_CHARS[(block >> 24) & 0x0F];
 	      }
 	      if (j % blockCount === 0) {
+	        s = cloneArray(s);
 	        f(s);
 	        i = 0;
 	      }
@@ -2339,11 +2181,12 @@ var sha3$1 = {exports: {}};
 	        array[j] = s[i];
 	      }
 	      if (j % blockCount === 0) {
+	        s = cloneArray(s);
 	        f(s);
 	      }
 	    }
 	    if (extraBytes) {
-	      array[i] = s[i];
+	      array[j] = s[i];
 	      buffer = buffer.slice(0, bytes);
 	    }
 	    return buffer;
@@ -2367,6 +2210,7 @@ var sha3$1 = {exports: {}};
 	        array[offset + 3] = (block >> 24) & 0xFF;
 	      }
 	      if (j % blockCount === 0) {
+	        s = cloneArray(s);
 	        f(s);
 	      }
 	    }
@@ -2602,7 +2446,7 @@ const Symmetric = {
 const Asymmetric = {
     keySize: 32
 };
-const OneMillion = BigInt(1000000);
+const OneMillion = BigInt(1_000_000);
 const Version = 1;
 
 const crypto = {
@@ -2812,4 +2656,4 @@ var symmetric = /*#__PURE__*/Object.freeze({
     generateIv: generateIv
 });
 
-export { OneMillion as O, Symmetric as S, Version as V, generateSymmetricKey as a, getPublicKey as b, getSubtle as c, sign as d, ecies as e, symmetric as f, generatePrivateKey as g, commonjsGlobal as h, getDefaultExportFromCjs as i, concat as j, keccak256 as k, encrypt$1 as l, hexToBytes as m, decrypt$1 as n, generateIv as o, encrypt as p, decrypt as q, randomBytes as r, sha256 as s, Signature as t, utf8ToBytes as u, recoverPublicKey as v };
+export { OneMillion as O, Symmetric as S, Version as V, generateSymmetricKey as a, getPublicKey as b, getSubtle as c, sign as d, ecies as e, symmetric as f, generatePrivateKey as g, allocUnsafe as h, fromString as i, alloc as j, keccak256 as k, concat as l, getDefaultExportFromCjs as m, encrypt$1 as n, hexToBytes as o, decrypt$1 as p, generateIv as q, randomBytes as r, sha256 as s, encrypt as t, utf8ToBytes as u, decrypt as v, Signature as w, recoverPublicKey as x };