@lukso/web-components 1.172.13 → 1.172.17

package/dist/chunks/isAddress-BUdSrCaY.js

@@ -1,743 +0,0 @@
-import { B as BaseError } from './base-KJhhKWYy.js';
-
-function isHex(value, { strict = true } = {}) {
-    if (!value)
-        return false;
-    if (typeof value !== 'string')
-        return false;
-    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith('0x');
-}
-
-/**
- * @description Retrieves the size of the value (in bytes).
- *
- * @param value The value (hex or byte array) to retrieve the size of.
- * @returns The size of the value (in bytes).
- */
-function size(value) {
-    if (isHex(value, { strict: false }))
-        return Math.ceil((value.length - 2) / 2);
-    return value.length;
-}
-
-class SizeExceedsPaddingSizeError extends BaseError {
-    constructor({ size, targetSize, type, }) {
-        super(`${type.charAt(0).toUpperCase()}${type
-            .slice(1)
-            .toLowerCase()} size (${size}) exceeds padding size (${targetSize}).`, { name: 'SizeExceedsPaddingSizeError' });
-    }
-}
-
-function pad(hexOrBytes, { dir, size = 32 } = {}) {
-    if (typeof hexOrBytes === 'string')
-        return padHex(hexOrBytes, { dir, size });
-    return padBytes(hexOrBytes, { dir, size });
-}
-function padHex(hex_, { dir, size = 32 } = {}) {
-    if (size === null)
-        return hex_;
-    const hex = hex_.replace('0x', '');
-    if (hex.length > size * 2)
-        throw new SizeExceedsPaddingSizeError({
-            size: Math.ceil(hex.length / 2),
-            targetSize: size,
-            type: 'hex',
-        });
-    return `0x${hex[dir === 'right' ? 'padEnd' : 'padStart'](size * 2, '0')}`;
-}
-function padBytes(bytes, { dir, size = 32 } = {}) {
-    if (size === null)
-        return bytes;
-    if (bytes.length > size)
-        throw new SizeExceedsPaddingSizeError({
-            size: bytes.length,
-            targetSize: size,
-            type: 'bytes',
-        });
-    const paddedBytes = new Uint8Array(size);
-    for (let i = 0; i < size; i++) {
-        const padEnd = dir === 'right';
-        paddedBytes[padEnd ? i : size - i - 1] =
-            bytes[padEnd ? i : bytes.length - i - 1];
-    }
-    return paddedBytes;
-}
-
-class IntegerOutOfRangeError extends BaseError {
-    constructor({ max, min, signed, size, value, }) {
-        super(`Number "${value}" is not in safe ${size ? `${size * 8}-bit ${signed ? 'signed' : 'unsigned'} ` : ''}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: 'IntegerOutOfRangeError' });
-    }
-}
-class SizeOverflowError extends BaseError {
-    constructor({ givenSize, maxSize }) {
-        super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: 'SizeOverflowError' });
-    }
-}
-
-function assertSize(hexOrBytes, { size: size$1 }) {
-    if (size(hexOrBytes) > size$1)
-        throw new SizeOverflowError({
-            givenSize: size(hexOrBytes),
-            maxSize: size$1,
-        });
-}
-
-/**
- * Encodes a number or bigint into a hex string
- *
- * - Docs: https://viem.sh/docs/utilities/toHex#numbertohex
- *
- * @param value Value to encode.
- * @param opts Options.
- * @returns Hex value.
- *
- * @example
- * import { numberToHex } from 'viem'
- * const data = numberToHex(420)
- * // '0x1a4'
- *
- * @example
- * import { numberToHex } from 'viem'
- * const data = numberToHex(420, { size: 32 })
- * // '0x00000000000000000000000000000000000000000000000000000000000001a4'
- */
-function numberToHex(value_, opts = {}) {
-    const { signed, size } = opts;
-    const value = BigInt(value_);
-    let maxValue;
-    if (size) {
-        if (signed)
-            maxValue = (1n << (BigInt(size) * 8n - 1n)) - 1n;
-        else
-            maxValue = 2n ** (BigInt(size) * 8n) - 1n;
-    }
-    else if (typeof value_ === 'number') {
-        maxValue = BigInt(Number.MAX_SAFE_INTEGER);
-    }
-    const minValue = typeof maxValue === 'bigint' && signed ? -maxValue - 1n : 0;
-    if ((maxValue && value > maxValue) || value < minValue) {
-        const suffix = typeof value_ === 'bigint' ? 'n' : '';
-        throw new IntegerOutOfRangeError({
-            max: maxValue ? `${maxValue}${suffix}` : undefined,
-            min: `${minValue}${suffix}`,
-            signed,
-            size,
-            value: `${value_}${suffix}`,
-        });
-    }
-    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size * 8)) + BigInt(value) : value).toString(16)}`;
-    if (size)
-        return pad(hex, { size });
-    return hex;
-}
-
-const encoder = /*#__PURE__*/ new TextEncoder();
-/**
- * Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array.
- *
- * - Docs: https://viem.sh/docs/utilities/toBytes
- * - Example: https://viem.sh/docs/utilities/toBytes#usage
- *
- * @param value Value to encode.
- * @param opts Options.
- * @returns Byte array value.
- *
- * @example
- * import { toBytes } from 'viem'
- * const data = toBytes('Hello world')
- * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
- *
- * @example
- * import { toBytes } from 'viem'
- * const data = toBytes(420)
- * // Uint8Array([1, 164])
- *
- * @example
- * import { toBytes } from 'viem'
- * const data = toBytes(420, { size: 4 })
- * // Uint8Array([0, 0, 1, 164])
- */
-function toBytes$1(value, opts = {}) {
-    if (typeof value === 'number' || typeof value === 'bigint')
-        return numberToBytes(value, opts);
-    if (typeof value === 'boolean')
-        return boolToBytes(value, opts);
-    if (isHex(value))
-        return hexToBytes(value, opts);
-    return stringToBytes(value, opts);
-}
-/**
- * Encodes a boolean into a byte array.
- *
- * - Docs: https://viem.sh/docs/utilities/toBytes#booltobytes
- *
- * @param value Boolean value to encode.
- * @param opts Options.
- * @returns Byte array value.
- *
- * @example
- * import { boolToBytes } from 'viem'
- * const data = boolToBytes(true)
- * // Uint8Array([1])
- *
- * @example
- * import { boolToBytes } from 'viem'
- * const data = boolToBytes(true, { size: 32 })
- * // Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
- */
-function boolToBytes(value, opts = {}) {
-    const bytes = new Uint8Array(1);
-    bytes[0] = Number(value);
-    if (typeof opts.size === 'number') {
-        assertSize(bytes, { size: opts.size });
-        return pad(bytes, { size: opts.size });
-    }
-    return bytes;
-}
-// We use very optimized technique to convert hex string to byte array
-const charCodeMap = {
-    zero: 48,
-    nine: 57,
-    A: 65,
-    F: 70,
-    a: 97,
-    f: 102,
-};
-function charCodeToBase16(char) {
-    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
-        return char - charCodeMap.zero;
-    if (char >= charCodeMap.A && char <= charCodeMap.F)
-        return char - (charCodeMap.A - 10);
-    if (char >= charCodeMap.a && char <= charCodeMap.f)
-        return char - (charCodeMap.a - 10);
-    return undefined;
-}
-/**
- * Encodes a hex string into a byte array.
- *
- * - Docs: https://viem.sh/docs/utilities/toBytes#hextobytes
- *
- * @param hex Hex string to encode.
- * @param opts Options.
- * @returns Byte array value.
- *
- * @example
- * import { hexToBytes } from 'viem'
- * const data = hexToBytes('0x48656c6c6f20776f726c6421')
- * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
- *
- * @example
- * import { hexToBytes } from 'viem'
- * const data = hexToBytes('0x48656c6c6f20776f726c6421', { size: 32 })
- * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
- */
-function hexToBytes(hex_, opts = {}) {
-    let hex = hex_;
-    if (opts.size) {
-        assertSize(hex, { size: opts.size });
-        hex = pad(hex, { dir: 'right', size: opts.size });
-    }
-    let hexString = hex.slice(2);
-    if (hexString.length % 2)
-        hexString = `0${hexString}`;
-    const length = hexString.length / 2;
-    const bytes = new Uint8Array(length);
-    for (let index = 0, j = 0; index < length; index++) {
-        const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
-        const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
-        if (nibbleLeft === undefined || nibbleRight === undefined) {
-            throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
-        }
-        bytes[index] = nibbleLeft * 16 + nibbleRight;
-    }
-    return bytes;
-}
-/**
- * Encodes a number into a byte array.
- *
- * - Docs: https://viem.sh/docs/utilities/toBytes#numbertobytes
- *
- * @param value Number to encode.
- * @param opts Options.
- * @returns Byte array value.
- *
- * @example
- * import { numberToBytes } from 'viem'
- * const data = numberToBytes(420)
- * // Uint8Array([1, 164])
- *
- * @example
- * import { numberToBytes } from 'viem'
- * const data = numberToBytes(420, { size: 4 })
- * // Uint8Array([0, 0, 1, 164])
- */
-function numberToBytes(value, opts) {
-    const hex = numberToHex(value, opts);
-    return hexToBytes(hex);
-}
-/**
- * Encodes a UTF-8 string into a byte array.
- *
- * - Docs: https://viem.sh/docs/utilities/toBytes#stringtobytes
- *
- * @param value String to encode.
- * @param opts Options.
- * @returns Byte array value.
- *
- * @example
- * import { stringToBytes } from 'viem'
- * const data = stringToBytes('Hello world!')
- * // Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])
- *
- * @example
- * import { stringToBytes } from 'viem'
- * const data = stringToBytes('Hello world!', { size: 32 })
- * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
- */
-function stringToBytes(value, opts = {}) {
-    const bytes = encoder.encode(value);
-    if (typeof opts.size === 'number') {
-        assertSize(bytes, { size: opts.size });
-        return pad(bytes, { dir: 'right', size: opts.size });
-    }
-    return bytes;
-}
-
-/**
- * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
- * @todo re-check https://issues.chromium.org/issues/42212588
- * @module
- */
-const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-const _32n = /* @__PURE__ */ BigInt(32);
-function fromBig(n, le = false) {
-    if (le)
-        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
-    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
-}
-function split(lst, le = false) {
-    const len = lst.length;
-    let Ah = new Uint32Array(len);
-    let Al = new Uint32Array(len);
-    for (let i = 0; i < len; i++) {
-        const { h, l } = fromBig(lst[i], le);
-        [Ah[i], Al[i]] = [h, l];
-    }
-    return [Ah, Al];
-}
-// Left rotate for Shift in [1, 32)
-const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
-const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
-// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
-const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
-const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
-
-/**
- * Utilities for hex, bytes, CSPRNG.
- * @module
- */
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
-// node.js versions earlier than v19 don't declare it in global scope.
-// For node.js, package.json#exports field mapping rewrites import
-// from `crypto` to `cryptoNode`, which imports native module.
-// Makes the utils un-importable in browsers without a bundler.
-// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
-/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
-function isBytes(a) {
-    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
-}
-/** Asserts something is positive integer. */
-function anumber(n) {
-    if (!Number.isSafeInteger(n) || n < 0)
-        throw new Error('positive integer expected, got ' + n);
-}
-/** Asserts something is Uint8Array. */
-function abytes(b, ...lengths) {
-    if (!isBytes(b))
-        throw new Error('Uint8Array expected');
-    if (lengths.length > 0 && !lengths.includes(b.length))
-        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
-}
-/** Asserts a hash instance has not been destroyed / finished */
-function aexists(instance, checkFinished = true) {
-    if (instance.destroyed)
-        throw new Error('Hash instance has been destroyed');
-    if (checkFinished && instance.finished)
-        throw new Error('Hash#digest() has already been called');
-}
-/** Asserts output is properly-sized byte array */
-function aoutput(out, instance) {
-    abytes(out);
-    const min = instance.outputLen;
-    if (out.length < min) {
-        throw new Error('digestInto() expects output buffer of length at least ' + min);
-    }
-}
-/** Cast u8 / u16 / u32 to u32. */
-function u32(arr) {
-    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-/** Zeroize a byte array. Warning: JS provides no guarantees. */
-function clean(...arrays) {
-    for (let i = 0; i < arrays.length; i++) {
-        arrays[i].fill(0);
-    }
-}
-/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
-const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
-/** The byte swap operation for uint32 */
-function byteSwap(word) {
-    return (((word << 24) & 0xff000000) |
-        ((word << 8) & 0xff0000) |
-        ((word >>> 8) & 0xff00) |
-        ((word >>> 24) & 0xff));
-}
-/** In place byte swap for Uint32Array */
-function byteSwap32(arr) {
-    for (let i = 0; i < arr.length; i++) {
-        arr[i] = byteSwap(arr[i]);
-    }
-    return arr;
-}
-const swap32IfBE = isLE
-    ? (u) => u
-    : byteSwap32;
-/**
- * Converts string to bytes using UTF8 encoding.
- * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
- */
-function utf8ToBytes(str) {
-    if (typeof str !== 'string')
-        throw new Error('string expected');
-    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
-}
-/**
- * Normalizes (non-hex) string or Uint8Array to Uint8Array.
- * Warning: when Uint8Array is passed, it would NOT get copied.
- * Keep in mind for future mutable operations.
- */
-function toBytes(data) {
-    if (typeof data === 'string')
-        data = utf8ToBytes(data);
-    abytes(data);
-    return data;
-}
-/** For runtime check if class implements interface */
-class Hash {
-}
-/** Wraps hash function, creating an interface on top of it */
-function createHasher(hashCons) {
-    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
-    const tmp = hashCons();
-    hashC.outputLen = tmp.outputLen;
-    hashC.blockLen = tmp.blockLen;
-    hashC.create = () => hashCons();
-    return hashC;
-}
-
-/**
- * SHA3 (keccak) hash function, based on a new "Sponge function" design.
- * Different from older hashes, the internal state is bigger than output size.
- *
- * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
- * [Website](https://keccak.team/keccak.html),
- * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
- *
- * Check out `sha3-addons` module for cSHAKE, k12, and others.
- * @module
- */
-// No __PURE__ annotations in sha3 header:
-// EVERYTHING is in fact used on every export.
-// Various per round constants calculations
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-const _2n = BigInt(2);
-const _7n = BigInt(7);
-const _256n = BigInt(256);
-const _0x71n = BigInt(0x71);
-const SHA3_PI = [];
-const SHA3_ROTL = [];
-const _SHA3_IOTA = [];
-for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
-    // Pi
-    [x, y] = [y, (2 * x + 3 * y) % 5];
-    SHA3_PI.push(2 * (5 * y + x));
-    // Rotational
-    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
-    // Iota
-    let t = _0n;
-    for (let j = 0; j < 7; j++) {
-        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
-        if (R & _2n)
-            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);
-    }
-    _SHA3_IOTA.push(t);
-}
-const IOTAS = split(_SHA3_IOTA, true);
-const SHA3_IOTA_H = IOTAS[0];
-const SHA3_IOTA_L = IOTAS[1];
-// Left rotation (without 0, 32, 64)
-const rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));
-const rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));
-/** `keccakf1600` internal function, additionally allows to adjust round count. */
-function keccakP(s, rounds = 24) {
-    const B = new Uint32Array(5 * 2);
-    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)
-    for (let round = 24 - rounds; round < 24; round++) {
-        // Theta θ
-        for (let x = 0; x < 10; x++)
-            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
-        for (let x = 0; x < 10; x += 2) {
-            const idx1 = (x + 8) % 10;
-            const idx0 = (x + 2) % 10;
-            const B0 = B[idx0];
-            const B1 = B[idx0 + 1];
-            const Th = rotlH(B0, B1, 1) ^ B[idx1];
-            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
-            for (let y = 0; y < 50; y += 10) {
-                s[x + y] ^= Th;
-                s[x + y + 1] ^= Tl;
-            }
-        }
-        // Rho (ρ) and Pi (π)
-        let curH = s[2];
-        let curL = s[3];
-        for (let t = 0; t < 24; t++) {
-            const shift = SHA3_ROTL[t];
-            const Th = rotlH(curH, curL, shift);
-            const Tl = rotlL(curH, curL, shift);
-            const PI = SHA3_PI[t];
-            curH = s[PI];
-            curL = s[PI + 1];
-            s[PI] = Th;
-            s[PI + 1] = Tl;
-        }
-        // Chi (χ)
-        for (let y = 0; y < 50; y += 10) {
-            for (let x = 0; x < 10; x++)
-                B[x] = s[y + x];
-            for (let x = 0; x < 10; x++)
-                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
-        }
-        // Iota (ι)
-        s[0] ^= SHA3_IOTA_H[round];
-        s[1] ^= SHA3_IOTA_L[round];
-    }
-    clean(B);
-}
-/** Keccak sponge function. */
-class Keccak extends Hash {
-    // NOTE: we accept arguments in bytes instead of bits here.
-    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
-        super();
-        this.pos = 0;
-        this.posOut = 0;
-        this.finished = false;
-        this.destroyed = false;
-        this.enableXOF = false;
-        this.blockLen = blockLen;
-        this.suffix = suffix;
-        this.outputLen = outputLen;
-        this.enableXOF = enableXOF;
-        this.rounds = rounds;
-        // Can be passed from user as dkLen
-        anumber(outputLen);
-        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
-        // 0 < blockLen < 200
-        if (!(0 < blockLen && blockLen < 200))
-            throw new Error('only keccak-f1600 function is supported');
-        this.state = new Uint8Array(200);
-        this.state32 = u32(this.state);
-    }
-    clone() {
-        return this._cloneInto();
-    }
-    keccak() {
-        swap32IfBE(this.state32);
-        keccakP(this.state32, this.rounds);
-        swap32IfBE(this.state32);
-        this.posOut = 0;
-        this.pos = 0;
-    }
-    update(data) {
-        aexists(this);
-        data = toBytes(data);
-        abytes(data);
-        const { blockLen, state } = this;
-        const len = data.length;
-        for (let pos = 0; pos < len;) {
-            const take = Math.min(blockLen - this.pos, len - pos);
-            for (let i = 0; i < take; i++)
-                state[this.pos++] ^= data[pos++];
-            if (this.pos === blockLen)
-                this.keccak();
-        }
-        return this;
-    }
-    finish() {
-        if (this.finished)
-            return;
-        this.finished = true;
-        const { state, suffix, pos, blockLen } = this;
-        // Do the padding
-        state[pos] ^= suffix;
-        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
-            this.keccak();
-        state[blockLen - 1] ^= 0x80;
-        this.keccak();
-    }
-    writeInto(out) {
-        aexists(this, false);
-        abytes(out);
-        this.finish();
-        const bufferOut = this.state;
-        const { blockLen } = this;
-        for (let pos = 0, len = out.length; pos < len;) {
-            if (this.posOut >= blockLen)
-                this.keccak();
-            const take = Math.min(blockLen - this.posOut, len - pos);
-            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
-            this.posOut += take;
-            pos += take;
-        }
-        return out;
-    }
-    xofInto(out) {
-        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF
-        if (!this.enableXOF)
-            throw new Error('XOF is not possible for this instance');
-        return this.writeInto(out);
-    }
-    xof(bytes) {
-        anumber(bytes);
-        return this.xofInto(new Uint8Array(bytes));
-    }
-    digestInto(out) {
-        aoutput(out, this);
-        if (this.finished)
-            throw new Error('digest() was already called');
-        this.writeInto(out);
-        this.destroy();
-        return out;
-    }
-    digest() {
-        return this.digestInto(new Uint8Array(this.outputLen));
-    }
-    destroy() {
-        this.destroyed = true;
-        clean(this.state);
-    }
-    _cloneInto(to) {
-        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
-        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
-        to.state32.set(this.state32);
-        to.pos = this.pos;
-        to.posOut = this.posOut;
-        to.finished = this.finished;
-        to.rounds = rounds;
-        // Suffix can change in cSHAKE
-        to.suffix = suffix;
-        to.outputLen = outputLen;
-        to.enableXOF = enableXOF;
-        to.destroyed = this.destroyed;
-        return to;
-    }
-}
-const gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
-/** keccak-256 hash function. Different from SHA3-256. */
-const keccak_256 = /* @__PURE__ */ (() => gen(0x01, 136, 256 / 8))();
-
-function keccak256(value, to_) {
-    const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes$1(value) : value);
-    return bytes;
-}
-
-/**
- * Map with a LRU (Least recently used) policy.
- *
- * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
- */
-class LruMap extends Map {
-    constructor(size) {
-        super();
-        Object.defineProperty(this, "maxSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.maxSize = size;
-    }
-    get(key) {
-        const value = super.get(key);
-        if (super.has(key) && value !== undefined) {
-            this.delete(key);
-            super.set(key, value);
-        }
-        return value;
-    }
-    set(key, value) {
-        super.set(key, value);
-        if (this.maxSize && this.size > this.maxSize) {
-            const firstKey = this.keys().next().value;
-            if (firstKey)
-                this.delete(firstKey);
-        }
-        return this;
-    }
-}
-
-const checksumAddressCache = /*#__PURE__*/ new LruMap(8192);
-function checksumAddress(address_, 
-/**
- * Warning: EIP-1191 checksum addresses are generally not backwards compatible with the
- * wider Ethereum ecosystem, meaning it will break when validated against an application/tool
- * that relies on EIP-55 checksum encoding (checksum without chainId).
- *
- * It is highly recommended to not use this feature unless you
- * know what you are doing.
- *
- * See more: https://github.com/ethereum/EIPs/issues/1121
- */
-chainId) {
-    if (checksumAddressCache.has(`${address_}.${chainId}`))
-        return checksumAddressCache.get(`${address_}.${chainId}`);
-    const hexAddress = address_.substring(2).toLowerCase();
-    const hash = keccak256(stringToBytes(hexAddress));
-    const address = (hexAddress).split('');
-    for (let i = 0; i < 40; i += 2) {
-        if (hash[i >> 1] >> 4 >= 8 && address[i]) {
-            address[i] = address[i].toUpperCase();
-        }
-        if ((hash[i >> 1] & 0x0f) >= 8 && address[i + 1]) {
-            address[i + 1] = address[i + 1].toUpperCase();
-        }
-    }
-    const result = `0x${address.join('')}`;
-    checksumAddressCache.set(`${address_}.${chainId}`, result);
-    return result;
-}
-
-const addressRegex = /^0x[a-fA-F0-9]{40}$/;
-/** @internal */
-const isAddressCache = /*#__PURE__*/ new LruMap(8192);
-function isAddress(address, options) {
-    const { strict = true } = {};
-    const cacheKey = `${address}.${strict}`;
-    if (isAddressCache.has(cacheKey))
-        return isAddressCache.get(cacheKey);
-    const result = (() => {
-        if (!addressRegex.test(address))
-            return false;
-        if (address.toLowerCase() === address)
-            return true;
-        if (strict)
-            return checksumAddress(address) === address;
-        return true;
-    })();
-    isAddressCache.set(cacheKey, result);
-    return result;
-}
-
-export { isAddress as i };