@sentio/sdk-bundle 4.0.1-rc.2 → 4.0.1-rc.4

package/dist/base-BvfRCgEy.js

@@ -1,959 +0,0 @@
-import { a as __name } from "./bignumber-DddanwOv.js";
-
-//#region ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/utils.js
-/**
-* Utilities for hex, bytes, CSPRNG.
-* @module
-*/
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
-function isBytes$1(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-__name(isBytes$1, "isBytes");
-/** Asserts something is positive integer. */
-function anumber$1(n, title = "") {
-	if (!Number.isSafeInteger(n) || n < 0) {
-		const prefix = title && `"${title}" `;
-		throw new Error(`${prefix}expected integer >= 0, got ${n}`);
-	}
-}
-__name(anumber$1, "anumber");
-/** Asserts something is Uint8Array. */
-function abytes$1(value, length, title = "") {
-	const bytes = isBytes$1(value);
-	const len = value?.length;
-	const needsLen = length !== void 0;
-	if (!bytes || needsLen && len !== length) {
-		const prefix = title && `"${title}" `;
-		const ofLen = needsLen ? ` of length ${length}` : "";
-		const got = bytes ? `length=${len}` : `type=${typeof value}`;
-		throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
-	}
-	return value;
-}
-__name(abytes$1, "abytes");
-/** Asserts something is hash */
-function ahash(h) {
-	if (typeof h !== "function" || typeof h.create !== "function") throw new Error("Hash must wrapped by utils.createHasher");
-	anumber$1(h.outputLen);
-	anumber$1(h.blockLen);
-}
-/** 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$1(out, void 0, "digestInto() output");
-	const min = instance.outputLen;
-	if (out.length < min) throw new Error("\"digestInto() output\" expected to be of length >=" + 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);
-}
-/** Create DataView of an array for easy byte-level manipulation. */
-function createView(arr) {
-	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-/** The rotate right (circular right shift) operation for uint32 */
-function rotr(word, shift) {
-	return word << 32 - shift | word >>> shift;
-}
-/** The rotate left (circular left shift) operation for uint32 */
-function rotl(word, shift) {
-	return word << shift | word >>> 32 - shift >>> 0;
-}
-/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
-const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-/** The byte swap operation for uint32 */
-function byteSwap(word) {
-	return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
-}
-/** Conditionally byte swap if on a big-endian platform */
-const swap8IfBE = isLE ? (n) => n : (n) => byteSwap(n);
-/** 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;
-const hasHexBuiltin$1 = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
-const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-/**
-* Convert byte array to hex string. Uses built-in function, when available.
-* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
-*/
-function bytesToHex(bytes) {
-	abytes$1(bytes);
-	if (hasHexBuiltin$1) return bytes.toHex();
-	let hex = "";
-	for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
-	return hex;
-}
-const asciis = {
-	_0: 48,
-	_9: 57,
-	A: 65,
-	F: 70,
-	a: 97,
-	f: 102
-};
-function asciiToBase16(ch) {
-	if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0;
-	if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10);
-	if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10);
-}
-/**
-* Convert hex string to byte array. Uses built-in function, when available.
-* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
-*/
-function hexToBytes(hex) {
-	if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
-	if (hasHexBuiltin$1) return Uint8Array.fromHex(hex);
-	const hl = hex.length;
-	const al = hl / 2;
-	if (hl % 2) throw new Error("hex string expected, got unpadded hex of length " + hl);
-	const array = new Uint8Array(al);
-	for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
-		const n1 = asciiToBase16(hex.charCodeAt(hi));
-		const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
-		if (n1 === void 0 || n2 === void 0) {
-			const char = hex[hi] + hex[hi + 1];
-			throw new Error("hex string expected, got non-hex character \"" + char + "\" at index " + hi);
-		}
-		array[ai] = n1 * 16 + n2;
-	}
-	return array;
-}
-/**
-* Converts string to bytes using UTF8 encoding.
-* Built-in doesn't validate input to be string: we do the check.
-* @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));
-}
-/**
-* Helper for KDFs: consumes uint8array or string.
-* When string is passed, does utf8 decoding, using TextDecoder.
-*/
-function kdfInputToBytes(data, errorTitle = "") {
-	if (typeof data === "string") return utf8ToBytes(data);
-	return abytes$1(data, void 0, errorTitle);
-}
-/** Copies several Uint8Arrays into one. */
-function concatBytes(...arrays) {
-	let sum = 0;
-	for (let i = 0; i < arrays.length; i++) {
-		const a = arrays[i];
-		abytes$1(a);
-		sum += a.length;
-	}
-	const res = new Uint8Array(sum);
-	for (let i = 0, pad = 0; i < arrays.length; i++) {
-		const a = arrays[i];
-		res.set(a, pad);
-		pad += a.length;
-	}
-	return res;
-}
-/** Merges default options and passed options. */
-function checkOpts(defaults, opts) {
-	if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]") throw new Error("options must be object or undefined");
-	return Object.assign(defaults, opts);
-}
-/** Creates function with outputLen, blockLen, create properties from a class constructor. */
-function createHasher(hashCons, info = {}) {
-	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
-	const tmp = hashCons(void 0);
-	hashC.outputLen = tmp.outputLen;
-	hashC.blockLen = tmp.blockLen;
-	hashC.create = (opts) => hashCons(opts);
-	Object.assign(hashC, info);
-	return Object.freeze(hashC);
-}
-/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
-function randomBytes(bytesLength = 32) {
-	const cr = typeof globalThis === "object" ? globalThis.crypto : null;
-	if (typeof cr?.getRandomValues !== "function") throw new Error("crypto.getRandomValues must be defined");
-	return cr.getRandomValues(new Uint8Array(bytesLength));
-}
-/** Creates OID opts for NIST hashes, with prefix 06 09 60 86 48 01 65 03 04 02. */
-const oidNist = (suffix) => ({ oid: Uint8Array.from([
-	6,
-	9,
-	96,
-	134,
-	72,
-	1,
-	101,
-	3,
-	4,
-	2,
-	suffix
-]) });
-
-//#endregion
-//#region ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/_md.js
-/**
-* Internal Merkle-Damgard hash utils.
-* @module
-*/
-/** Choice: a ? b : c */
-function Chi(a, b, c) {
-	return a & b ^ ~a & c;
-}
-/** Majority function, true if any two inputs is true. */
-function Maj(a, b, c) {
-	return a & b ^ a & c ^ b & c;
-}
-/**
-* Merkle-Damgard hash construction base class.
-* Could be used to create MD5, RIPEMD, SHA1, SHA2.
-*/
-var HashMD = class {
-	blockLen;
-	outputLen;
-	padOffset;
-	isLE;
-	buffer;
-	view;
-	finished = false;
-	length = 0;
-	pos = 0;
-	destroyed = false;
-	constructor(blockLen, outputLen, padOffset, isLE) {
-		this.blockLen = blockLen;
-		this.outputLen = outputLen;
-		this.padOffset = padOffset;
-		this.isLE = isLE;
-		this.buffer = new Uint8Array(blockLen);
-		this.view = createView(this.buffer);
-	}
-	update(data) {
-		aexists(this);
-		abytes$1(data);
-		const { view, buffer, blockLen } = this;
-		const len = data.length;
-		for (let pos = 0; pos < len;) {
-			const take = Math.min(blockLen - this.pos, len - pos);
-			if (take === blockLen) {
-				const dataView = createView(data);
-				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
-				continue;
-			}
-			buffer.set(data.subarray(pos, pos + take), this.pos);
-			this.pos += take;
-			pos += take;
-			if (this.pos === blockLen) {
-				this.process(view, 0);
-				this.pos = 0;
-			}
-		}
-		this.length += data.length;
-		this.roundClean();
-		return this;
-	}
-	digestInto(out) {
-		aexists(this);
-		aoutput(out, this);
-		this.finished = true;
-		const { buffer, view, blockLen, isLE } = this;
-		let { pos } = this;
-		buffer[pos++] = 128;
-		clean(this.buffer.subarray(pos));
-		if (this.padOffset > blockLen - pos) {
-			this.process(view, 0);
-			pos = 0;
-		}
-		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
-		view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
-		this.process(view, 0);
-		const oview = createView(out);
-		const len = this.outputLen;
-		if (len % 4) throw new Error("_sha2: outputLen must be aligned to 32bit");
-		const outLen = len / 4;
-		const state = this.get();
-		if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
-		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
-	}
-	digest() {
-		const { buffer, outputLen } = this;
-		this.digestInto(buffer);
-		const res = buffer.slice(0, outputLen);
-		this.destroy();
-		return res;
-	}
-	_cloneInto(to) {
-		to ||= new this.constructor();
-		to.set(...this.get());
-		const { blockLen, buffer, length, finished, destroyed, pos } = this;
-		to.destroyed = destroyed;
-		to.finished = finished;
-		to.length = length;
-		to.pos = pos;
-		if (length % blockLen) to.buffer.set(buffer);
-		return to;
-	}
-	clone() {
-		return this._cloneInto();
-	}
-};
-/**
-* Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
-* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
-*/
-/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
-const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-	1779033703,
-	3144134277,
-	1013904242,
-	2773480762,
-	1359893119,
-	2600822924,
-	528734635,
-	1541459225
-]);
-/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */
-const SHA512_IV = /* @__PURE__ */ Uint32Array.from([
-	1779033703,
-	4089235720,
-	3144134277,
-	2227873595,
-	1013904242,
-	4271175723,
-	2773480762,
-	1595750129,
-	1359893119,
-	2917565137,
-	2600822924,
-	725511199,
-	528734635,
-	4215389547,
-	1541459225,
-	327033209
-]);
-
-//#endregion
-//#region ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/_u64.js
-/**
-* 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];
-}
-const shrSH = (h, _l, s) => h >>> s;
-const shrSL = (h, l, s) => h << 32 - s | l >>> s;
-const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
-const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
-const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
-const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
-const rotr32H = (_h, l) => l;
-const rotr32L = (h, _l) => h;
-function add(Ah, Al, Bh, Bl) {
-	const l = (Al >>> 0) + (Bl >>> 0);
-	return {
-		h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
-		l: l | 0
-	};
-}
-const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
-const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
-const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
-const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
-const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
-const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
-
-//#endregion
-//#region ../../node_modules/.pnpm/@scure+base@2.0.0/node_modules/@scure/base/index.js
-/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-function isBytes(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-/** Asserts something is Uint8Array. */
-function abytes(b) {
-	if (!isBytes(b)) throw new Error("Uint8Array expected");
-}
-function isArrayOf(isString, arr) {
-	if (!Array.isArray(arr)) return false;
-	if (arr.length === 0) return true;
-	if (isString) return arr.every((item) => typeof item === "string");
-	else return arr.every((item) => Number.isSafeInteger(item));
-}
-function afn(input) {
-	if (typeof input !== "function") throw new Error("function expected");
-	return true;
-}
-function astr(label, input) {
-	if (typeof input !== "string") throw new Error(`${label}: string expected`);
-	return true;
-}
-function anumber(n) {
-	if (!Number.isSafeInteger(n)) throw new Error(`invalid integer: ${n}`);
-}
-function aArr(input) {
-	if (!Array.isArray(input)) throw new Error("array expected");
-}
-function astrArr(label, input) {
-	if (!isArrayOf(true, input)) throw new Error(`${label}: array of strings expected`);
-}
-function anumArr(label, input) {
-	if (!isArrayOf(false, input)) throw new Error(`${label}: array of numbers expected`);
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function chain(...args) {
-	const id = (a) => a;
-	const wrap = (a, b) => (c) => a(b(c));
-	return {
-		encode: args.map((x) => x.encode).reduceRight(wrap, id),
-		decode: args.map((x) => x.decode).reduce(wrap, id)
-	};
-}
-/**
-* Encodes integer radix representation to array of strings using alphabet and back.
-* Could also be array of strings.
-* @__NO_SIDE_EFFECTS__
-*/
-function alphabet(letters) {
-	const lettersA = typeof letters === "string" ? letters.split("") : letters;
-	const len = lettersA.length;
-	astrArr("alphabet", lettersA);
-	const indexes = new Map(lettersA.map((l, i) => [l, i]));
-	return {
-		encode: (digits) => {
-			aArr(digits);
-			return digits.map((i) => {
-				if (!Number.isSafeInteger(i) || i < 0 || i >= len) throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
-				return lettersA[i];
-			});
-		},
-		decode: (input) => {
-			aArr(input);
-			return input.map((letter) => {
-				astr("alphabet.decode", letter);
-				const i = indexes.get(letter);
-				if (i === void 0) throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
-				return i;
-			});
-		}
-	};
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function join(separator = "") {
-	astr("join", separator);
-	return {
-		encode: (from) => {
-			astrArr("join.decode", from);
-			return from.join(separator);
-		},
-		decode: (to) => {
-			astr("join.decode", to);
-			return to.split(separator);
-		}
-	};
-}
-/**
-* Pad strings array so it has integer number of bits
-* @__NO_SIDE_EFFECTS__
-*/
-function padding(bits, chr = "=") {
-	anumber(bits);
-	astr("padding", chr);
-	return {
-		encode(data) {
-			astrArr("padding.encode", data);
-			while (data.length * bits % 8) data.push(chr);
-			return data;
-		},
-		decode(input) {
-			astrArr("padding.decode", input);
-			let end = input.length;
-			if (end * bits % 8) throw new Error("padding: invalid, string should have whole number of bytes");
-			for (; end > 0 && input[end - 1] === chr; end--) if ((end - 1) * bits % 8 === 0) throw new Error("padding: invalid, string has too much padding");
-			return input.slice(0, end);
-		}
-	};
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function normalize(fn) {
-	afn(fn);
-	return {
-		encode: (from) => from,
-		decode: (to) => fn(to)
-	};
-}
-/**
-* Slow: O(n^2) time complexity
-*/
-function convertRadix(data, from, to) {
-	if (from < 2) throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
-	if (to < 2) throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
-	aArr(data);
-	if (!data.length) return [];
-	let pos = 0;
-	const res = [];
-	const digits = Array.from(data, (d) => {
-		anumber(d);
-		if (d < 0 || d >= from) throw new Error(`invalid integer: ${d}`);
-		return d;
-	});
-	const dlen = digits.length;
-	while (true) {
-		let carry = 0;
-		let done = true;
-		for (let i = pos; i < dlen; i++) {
-			const digit = digits[i];
-			const fromCarry = from * carry;
-			const digitBase = fromCarry + digit;
-			if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) throw new Error("convertRadix: carry overflow");
-			const div = digitBase / to;
-			carry = digitBase % to;
-			const rounded = Math.floor(div);
-			digits[i] = rounded;
-			if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase) throw new Error("convertRadix: carry overflow");
-			if (!done) continue;
-			else if (!rounded) pos = i;
-			else done = false;
-		}
-		res.push(carry);
-		if (done) break;
-	}
-	for (let i = 0; i < data.length - 1 && data[i] === 0; i++) res.push(0);
-	return res.reverse();
-}
-const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
-const radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
-const powers = /* @__PURE__ */ (() => {
-	let res = [];
-	for (let i = 0; i < 40; i++) res.push(2 ** i);
-	return res;
-})();
-/**
-* Implemented with numbers, because BigInt is 5x slower
-*/
-function convertRadix2(data, from, to, padding) {
-	aArr(data);
-	if (from <= 0 || from > 32) throw new Error(`convertRadix2: wrong from=${from}`);
-	if (to <= 0 || to > 32) throw new Error(`convertRadix2: wrong to=${to}`);
-	if (/* @__PURE__ */ radix2carry(from, to) > 32) throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
-	let carry = 0;
-	let pos = 0;
-	const max = powers[from];
-	const mask = powers[to] - 1;
-	const res = [];
-	for (const n of data) {
-		anumber(n);
-		if (n >= max) throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
-		carry = carry << from | n;
-		if (pos + from > 32) throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
-		pos += from;
-		for (; pos >= to; pos -= to) res.push((carry >> pos - to & mask) >>> 0);
-		const pow = powers[pos];
-		if (pow === void 0) throw new Error("invalid carry");
-		carry &= pow - 1;
-	}
-	carry = carry << to - pos & mask;
-	if (!padding && pos >= from) throw new Error("Excess padding");
-	if (!padding && carry > 0) throw new Error(`Non-zero padding: ${carry}`);
-	if (padding && pos > 0) res.push(carry >>> 0);
-	return res;
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function radix(num) {
-	anumber(num);
-	const _256 = 2 ** 8;
-	return {
-		encode: (bytes) => {
-			if (!isBytes(bytes)) throw new Error("radix.encode input should be Uint8Array");
-			return convertRadix(Array.from(bytes), _256, num);
-		},
-		decode: (digits) => {
-			anumArr("radix.decode", digits);
-			return Uint8Array.from(convertRadix(digits, num, _256));
-		}
-	};
-}
-/**
-* If both bases are power of same number (like `2**8 <-> 2**64`),
-* there is a linear algorithm. For now we have implementation for power-of-two bases only.
-* @__NO_SIDE_EFFECTS__
-*/
-function radix2(bits, revPadding = false) {
-	anumber(bits);
-	if (bits <= 0 || bits > 32) throw new Error("radix2: bits should be in (0..32]");
-	if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32) throw new Error("radix2: carry overflow");
-	return {
-		encode: (bytes) => {
-			if (!isBytes(bytes)) throw new Error("radix2.encode input should be Uint8Array");
-			return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
-		},
-		decode: (digits) => {
-			anumArr("radix2.decode", digits);
-			return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
-		}
-	};
-}
-function unsafeWrapper(fn) {
-	afn(fn);
-	return function(...args) {
-		try {
-			return fn.apply(null, args);
-		} catch (e) {}
-	};
-}
-function checksum(len, fn) {
-	anumber(len);
-	afn(fn);
-	return {
-		encode(data) {
-			if (!isBytes(data)) throw new Error("checksum.encode: input should be Uint8Array");
-			const sum = fn(data).slice(0, len);
-			const res = new Uint8Array(data.length + len);
-			res.set(data);
-			res.set(sum, data.length);
-			return res;
-		},
-		decode(data) {
-			if (!isBytes(data)) throw new Error("checksum.decode: input should be Uint8Array");
-			const payload = data.slice(0, -len);
-			const oldChecksum = data.slice(-len);
-			const newChecksum = fn(payload).slice(0, len);
-			for (let i = 0; i < len; i++) if (newChecksum[i] !== oldChecksum[i]) throw new Error("Invalid checksum");
-			return payload;
-		}
-	};
-}
-/**
-* base16 encoding from RFC 4648.
-* @example
-* ```js
-* base16.encode(Uint8Array.from([0x12, 0xab]));
-* // => '12AB'
-* ```
-*/
-const base16 = chain(radix2(4), alphabet("0123456789ABCDEF"), join(""));
-/**
-* base32 encoding from RFC 4648. Has padding.
-* Use `base32nopad` for unpadded version.
-* Also check out `base32hex`, `base32hexnopad`, `base32crockford`.
-* @example
-* ```js
-* base32.encode(Uint8Array.from([0x12, 0xab]));
-* // => 'CKVQ===='
-* base32.decode('CKVQ====');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-const base32 = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding(5), join(""));
-/**
-* base32 encoding from RFC 4648. No padding.
-* Use `base32` for padded version.
-* Also check out `base32hex`, `base32hexnopad`, `base32crockford`.
-* @example
-* ```js
-* base32nopad.encode(Uint8Array.from([0x12, 0xab]));
-* // => 'CKVQ'
-* base32nopad.decode('CKVQ');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-const base32nopad = chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), join(""));
-/**
-* base32 encoding from RFC 4648. Padded. Compared to ordinary `base32`, slightly different alphabet.
-* Use `base32hexnopad` for unpadded version.
-* @example
-* ```js
-* base32hex.encode(Uint8Array.from([0x12, 0xab]));
-* // => '2ALG===='
-* base32hex.decode('2ALG====');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-const base32hex = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding(5), join(""));
-/**
-* base32 encoding from RFC 4648. No padding. Compared to ordinary `base32`, slightly different alphabet.
-* Use `base32hex` for padded version.
-* @example
-* ```js
-* base32hexnopad.encode(Uint8Array.from([0x12, 0xab]));
-* // => '2ALG'
-* base32hexnopad.decode('2ALG');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-const base32hexnopad = chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), join(""));
-/**
-* base32 encoding from RFC 4648. Doug Crockford's version.
-* https://www.crockford.com/base32.html
-* @example
-* ```js
-* base32crockford.encode(Uint8Array.from([0x12, 0xab]));
-* // => '2ANG'
-* base32crockford.decode('2ANG');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-const base32crockford = chain(radix2(5), alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join(""), normalize((s) => s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
-const hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function")();
-const decodeBase64Builtin = (s, isUrl) => {
-	astr("base64", s);
-	const re = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/;
-	const alphabet = isUrl ? "base64url" : "base64";
-	if (s.length > 0 && !re.test(s)) throw new Error("invalid base64");
-	return Uint8Array.fromBase64(s, {
-		alphabet,
-		lastChunkHandling: "strict"
-	});
-};
-/**
-* base64 from RFC 4648. Padded.
-* Use `base64nopad` for unpadded version.
-* Also check out `base64url`, `base64urlnopad`.
-* Falls back to built-in function, when available.
-* @example
-* ```js
-* base64.encode(Uint8Array.from([0x12, 0xab]));
-* // => 'Eqs='
-* base64.decode('Eqs=');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-const base64 = hasBase64Builtin ? {
-	encode(b) {
-		abytes(b);
-		return b.toBase64();
-	},
-	decode(s) {
-		return decodeBase64Builtin(s, false);
-	}
-} : chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6), join(""));
-/**
-* base64 from RFC 4648. No padding.
-* Use `base64` for padded version.
-* @example
-* ```js
-* base64nopad.encode(Uint8Array.from([0x12, 0xab]));
-* // => 'Eqs'
-* base64nopad.decode('Eqs');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-const base64nopad = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), join(""));
-/**
-* base64 from RFC 4648, using URL-safe alphabet. Padded.
-* Use `base64urlnopad` for unpadded version.
-* Falls back to built-in function, when available.
-* @example
-* ```js
-* base64url.encode(Uint8Array.from([0x12, 0xab]));
-* // => 'Eqs='
-* base64url.decode('Eqs=');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-const base64url = hasBase64Builtin ? {
-	encode(b) {
-		abytes(b);
-		return b.toBase64({ alphabet: "base64url" });
-	},
-	decode(s) {
-		return decodeBase64Builtin(s, true);
-	}
-} : chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6), join(""));
-/**
-* base64 from RFC 4648, using URL-safe alphabet. No padding.
-* Use `base64url` for padded version.
-* @example
-* ```js
-* base64urlnopad.encode(Uint8Array.from([0x12, 0xab]));
-* // => 'Eqs'
-* base64urlnopad.decode('Eqs');
-* // => Uint8Array.from([0x12, 0xab])
-* ```
-*/
-const base64urlnopad = chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), join(""));
-const genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => chain(radix(58), alphabet(abc), join(""));
-/**
-* base58: base64 without ambigous characters +, /, 0, O, I, l.
-* Quadratic (O(n^2)) - so, can't be used on large inputs.
-* @example
-* ```js
-* base58.decode('01abcdef');
-* // => '3UhJW'
-* ```
-*/
-const base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
-/**
-* Method, which creates base58check encoder.
-* Requires function, calculating sha256.
-*/
-const createBase58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), base58);
-const BECH_ALPHABET = chain(alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), join(""));
-const POLYMOD_GENERATORS = [
-	996825010,
-	642813549,
-	513874426,
-	1027748829,
-	705979059
-];
-function bech32Polymod(pre) {
-	const b = pre >> 25;
-	let chk = (pre & 33554431) << 5;
-	for (let i = 0; i < POLYMOD_GENERATORS.length; i++) if ((b >> i & 1) === 1) chk ^= POLYMOD_GENERATORS[i];
-	return chk;
-}
-function bechChecksum(prefix, words, encodingConst = 1) {
-	const len = prefix.length;
-	let chk = 1;
-	for (let i = 0; i < len; i++) {
-		const c = prefix.charCodeAt(i);
-		if (c < 33 || c > 126) throw new Error(`Invalid prefix (${prefix})`);
-		chk = bech32Polymod(chk) ^ c >> 5;
-	}
-	chk = bech32Polymod(chk);
-	for (let i = 0; i < len; i++) chk = bech32Polymod(chk) ^ prefix.charCodeAt(i) & 31;
-	for (let v of words) chk = bech32Polymod(chk) ^ v;
-	for (let i = 0; i < 6; i++) chk = bech32Polymod(chk);
-	chk ^= encodingConst;
-	return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function genBech32(encoding) {
-	const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939;
-	const _words = radix2(5);
-	const fromWords = _words.decode;
-	const toWords = _words.encode;
-	const fromWordsUnsafe = unsafeWrapper(fromWords);
-	function encode(prefix, words, limit = 90) {
-		astr("bech32.encode prefix", prefix);
-		if (isBytes(words)) words = Array.from(words);
-		anumArr("bech32.encode", words);
-		const plen = prefix.length;
-		if (plen === 0) throw new TypeError(`Invalid prefix length ${plen}`);
-		const actualLength = plen + 7 + words.length;
-		if (limit !== false && actualLength > limit) throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
-		const lowered = prefix.toLowerCase();
-		const sum = bechChecksum(lowered, words, ENCODING_CONST);
-		return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
-	}
-	function decode(str, limit = 90) {
-		astr("bech32.decode input", str);
-		const slen = str.length;
-		if (slen < 8 || limit !== false && slen > limit) throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
-		const lowered = str.toLowerCase();
-		if (str !== lowered && str !== str.toUpperCase()) throw new Error(`String must be lowercase or uppercase`);
-		const sepIndex = lowered.lastIndexOf("1");
-		if (sepIndex === 0 || sepIndex === -1) throw new Error(`Letter "1" must be present between prefix and data only`);
-		const prefix = lowered.slice(0, sepIndex);
-		const data = lowered.slice(sepIndex + 1);
-		if (data.length < 6) throw new Error("Data must be at least 6 characters long");
-		const words = BECH_ALPHABET.decode(data).slice(0, -6);
-		const sum = bechChecksum(prefix, words, ENCODING_CONST);
-		if (!data.endsWith(sum)) throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
-		return {
-			prefix,
-			words
-		};
-	}
-	const decodeUnsafe = unsafeWrapper(decode);
-	function decodeToBytes(str) {
-		const { prefix, words } = decode(str, false);
-		return {
-			prefix,
-			words,
-			bytes: fromWords(words)
-		};
-	}
-	function encodeFromBytes(prefix, bytes) {
-		return encode(prefix, toWords(bytes));
-	}
-	return {
-		encode,
-		decode,
-		encodeFromBytes,
-		decodeToBytes,
-		decodeUnsafe,
-		fromWords,
-		fromWordsUnsafe,
-		toWords
-	};
-}
-/**
-* bech32 from BIP 173. Operates on words.
-* For high-level, check out scure-btc-signer:
-* https://github.com/paulmillr/scure-btc-signer.
-*/
-const bech32 = genBech32("bech32");
-/**
-* bech32m from BIP 350. Operates on words.
-* It was to mitigate `bech32` weaknesses.
-* For high-level, check out scure-btc-signer:
-* https://github.com/paulmillr/scure-btc-signer.
-*/
-const bech32m = genBech32("bech32m");
-const hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
-const hexBuiltin = {
-	encode(data) {
-		abytes(data);
-		return data.toHex();
-	},
-	decode(s) {
-		astr("hex", s);
-		return Uint8Array.fromHex(s);
-	}
-};
-/**
-* hex string decoder. Uses built-in function, when available.
-* @example
-* ```js
-* const b = hex.decode("0102ff"); // => new Uint8Array([ 1, 2, 255 ])
-* const str = hex.encode(b); // "0102ff"
-* ```
-*/
-const hex = hasHexBuiltin ? hexBuiltin : chain(radix2(4), alphabet("0123456789abcdef"), join(""), normalize((s) => {
-	if (typeof s !== "string" || s.length % 2 !== 0) throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
-	return s.toLowerCase();
-}));
-
-//#endregion
-export { bytesToHex as A, randomBytes as B, SHA256_IV as C, ahash as D, aexists as E, createView as F, u32 as G, rotr as H, hexToBytes as I, isBytes$1 as L, clean as M, concatBytes as N, anumber$1 as O, createHasher as P, kdfInputToBytes as R, Maj as S, abytes$1 as T, swap32IfBE as U, rotl as V, swap8IfBE as W, shrSH as _, add3L as a, Chi as b, add5H as c, rotr32H as d, rotr32L as f, rotrSL as g, rotrSH as h, add3H as i, checkOpts as j, aoutput as k, add5L as l, rotrBL as m, createBase58check as n, add4H as o, rotrBH as p, add as r, add4L as s, base58 as t, fromBig as u, shrSL as v, SHA512_IV as w, HashMD as x, split as y, oidNist as z };
-//# sourceMappingURL=base-BvfRCgEy.js.map