zeed 1.3.0 → 1.3.1

package/dist/bin-BAoS4qtm.mjs

@@ -0,0 +1,593 @@
+import { jsonStringifySafe } from "./common/data/json.mjs";
+
+//#region src/common/data/basex-secure.ts
+/**
+* @__NO_SIDE_EFFECTS__
+*/
+function assertNumber(n) {
+	if (!Number.isSafeInteger(n)) throw new Error(`Wrong integer: ${n}`);
+}
+function isBytes(a) {
+	return a instanceof Uint8Array || a != null && typeof a === "object" && a.constructor.name === "Uint8Array";
+}
+/**
+* @__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
+* @__NO_SIDE_EFFECTS__
+*/
+function alphabet(alphabet) {
+	return {
+		encode: (digits) => {
+			if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number") throw new Error("alphabet.encode input should be an array of numbers");
+			return digits.map((i) => {
+				assertNumber(i);
+				if (i < 0 || i >= alphabet.length) throw new Error(`Digit index outside alphabet: ${i} (alphabet: ${alphabet.length})`);
+				return alphabet[i];
+			});
+		},
+		decode: (input) => {
+			if (!Array.isArray(input) || input.length && typeof input[0] !== "string") throw new Error("alphabet.decode input should be array of strings");
+			return input.map((letter) => {
+				if (typeof letter !== "string") throw new Error(`alphabet.decode: not string element=${letter}`);
+				const index = alphabet.indexOf(letter);
+				if (index === -1) throw new Error(`Unknown letter: "${letter}". Allowed: ${alphabet}`);
+				return index;
+			});
+		}
+	};
+}
+/**
+* @__NO_SIDE_EFFECTS__
+*/
+function join(separator = "") {
+	if (typeof separator !== "string") throw new Error("join separator should be string");
+	return {
+		encode: (from) => {
+			if (!Array.isArray(from) || from.length && typeof from[0] !== "string") throw new Error("join.encode input should be array of strings");
+			for (let i of from) if (typeof i !== "string") throw new Error(`join.encode: non-string input=${i}`);
+			return from.join(separator);
+		},
+		decode: (to) => {
+			if (typeof to !== "string") throw new Error("join.decode input should be string");
+			return to.split(separator);
+		}
+	};
+}
+/**
+* Pad strings array so it has integer number of bits
+* @__NO_SIDE_EFFECTS__
+*/
+function padding(bits, chr = "=") {
+	assertNumber(bits);
+	if (typeof chr !== "string") throw new Error("padding chr should be string");
+	return {
+		encode(data) {
+			if (!Array.isArray(data) || data.length && typeof data[0] !== "string") throw new Error("padding.encode input should be array of strings");
+			for (let i of data) if (typeof i !== "string") throw new Error(`padding.encode: non-string input=${i}`);
+			while (data.length * bits % 8) data.push(chr);
+			return data;
+		},
+		decode(input) {
+			if (!Array.isArray(input) || input.length && typeof input[0] !== "string") throw new Error("padding.encode input should be array of strings");
+			for (let i of input) if (typeof i !== "string") throw new Error(`padding.decode: non-string input=${i}`);
+			let end = input.length;
+			if (end * bits % 8) throw new Error("Invalid padding: string should have whole number of bytes");
+			for (; end > 0 && input[end - 1] === chr; end--) if (!((end - 1) * bits % 8)) throw new Error("Invalid padding: string has too much padding");
+			return input.slice(0, end);
+		}
+	};
+}
+/**
+* @__NO_SIDE_EFFECTS__
+*/
+function normalize(fn) {
+	if (typeof fn !== "function") throw new Error("normalize fn should be function");
+	return {
+		encode: (from) => from,
+		decode: (to) => fn(to)
+	};
+}
+/**
+* Slow: O(n^2) time complexity
+* @__NO_SIDE_EFFECTS__
+*/
+function convertRadix(data, from, to) {
+	if (from < 2) throw new Error(`convertRadix: wrong from=${from}, base cannot be less than 2`);
+	if (to < 2) throw new Error(`convertRadix: wrong to=${to}, base cannot be less than 2`);
+	if (!Array.isArray(data)) throw new Error("convertRadix: data should be array");
+	if (!data.length) return [];
+	let pos = 0;
+	const res = [];
+	const digits = Array.from(data);
+	digits.forEach((d) => {
+		assertNumber(d);
+		if (d < 0 || d >= from) throw new Error(`Wrong integer: ${d}`);
+	});
+	while (true) {
+		let carry = 0;
+		let done = true;
+		for (let i = pos; i < digits.length; i++) {
+			const digit = digits[i];
+			const digitBase = from * carry + digit;
+			if (!Number.isSafeInteger(digitBase) || from * carry / from !== carry || digitBase - digit !== from * carry) throw new Error("convertRadix: carry overflow");
+			carry = digitBase % to;
+			const rounded = Math.floor(digitBase / to);
+			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 = /* @__NO_SIDE_EFFECTS__ */ (a, b) => !b ? a : /* @__PURE__ */ gcd(b, a % b);
+const radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - /* @__PURE__ */ gcd(from, to));
+/**
+* Implemented with numbers, because BigInt is 5x slower
+* @__NO_SIDE_EFFECTS__
+*/
+function convertRadix2(data, from, to, padding) {
+	if (!Array.isArray(data)) throw new Error("convertRadix2: data should be array");
+	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 mask = 2 ** to - 1;
+	const res = [];
+	for (const n of data) {
+		assertNumber(n);
+		if (n >= 2 ** from) 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);
+		carry &= 2 ** pos - 1;
+	}
+	carry = carry << to - pos & mask;
+	if (!padding && pos >= from) throw new Error("Excess padding");
+	if (!padding && carry) throw new Error(`Non-zero padding: ${carry}`);
+	if (padding && pos > 0) res.push(carry >>> 0);
+	return res;
+}
+/**
+* @__NO_SIDE_EFFECTS__
+*/
+function radix(num) {
+	assertNumber(num);
+	return {
+		encode: (bytes) => {
+			if (!isBytes(bytes)) throw new Error("radix.encode input should be Uint8Array");
+			return convertRadix(Array.from(bytes), 2 ** 8, num);
+		},
+		decode: (digits) => {
+			if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number") throw new Error("radix.decode input should be array of numbers");
+			return Uint8Array.from(convertRadix(digits, num, 2 ** 8));
+		}
+	};
+}
+/**
+* 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) {
+	assertNumber(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) => {
+			if (!Array.isArray(digits) || digits.length && typeof digits[0] !== "number") throw new Error("radix2.decode input should be array of numbers");
+			return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+		}
+	};
+}
+/**
+* @__NO_SIDE_EFFECTS__
+*/
+function unsafeWrapper(fn) {
+	if (typeof fn !== "function") throw new Error("unsafeWrapper fn should be function");
+	return function(...args) {
+		try {
+			return fn.apply(null, args);
+		} catch (e) {}
+	};
+}
+/**
+* @__NO_SIDE_EFFECTS__
+*/
+function checksum(len, fn) {
+	assertNumber(len);
+	if (typeof fn !== "function") throw new Error("checksum fn should be function");
+	return {
+		encode(data) {
+			if (!isBytes(data)) throw new Error("checksum.encode: input should be Uint8Array");
+			const checksum = fn(data).slice(0, len);
+			const res = new Uint8Array(data.length + len);
+			res.set(data);
+			res.set(checksum, 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 newChecksum = fn(payload).slice(0, len);
+			const oldChecksum = data.slice(-len);
+			for (let i = 0; i < len; i++) if (newChecksum[i] !== oldChecksum[i]) throw new Error("Invalid checksum");
+			return payload;
+		}
+	};
+}
+const utils = {
+	alphabet,
+	chain,
+	checksum,
+	convertRadix,
+	convertRadix2,
+	radix,
+	radix2,
+	join,
+	padding
+};
+const base16 = /* @__PURE__ */ chain(radix2(4), alphabet("0123456789ABCDEF"), join(""));
+const base32 = /* @__PURE__ */ chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding(5), join(""));
+const base32nopad = /* @__PURE__ */ chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), join(""));
+const base32hex = /* @__PURE__ */ chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding(5), join(""));
+const base32hexnopad = /* @__PURE__ */ chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), join(""));
+const base32agnoster = /* @__PURE__ */ chain(radix2(5), alphabet("0123456789abcdefghjkmnpqrtuvwxyz"), join(""));
+const base32crockford = /* @__PURE__ */ chain(radix2(5), alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join(""), normalize((s) => s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
+const base64 = /* @__PURE__ */ chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6), join(""));
+const base64nopad = /* @__PURE__ */ chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), join(""));
+const base64url = /* @__PURE__ */ chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6), join(""));
+const base64urlnopad = /* @__PURE__ */ chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), join(""));
+const genBase58 = (abc) => chain(radix(58), alphabet(abc), join(""));
+const base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+const base58flickr = /* @__PURE__ */ genBase58("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ");
+const base58xrp = /* @__PURE__ */ genBase58("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz");
+const XMR_BLOCK_LEN = [
+	0,
+	2,
+	3,
+	5,
+	6,
+	7,
+	9,
+	10,
+	11
+];
+const base58xmr = {
+	encode(data) {
+		let res = "";
+		for (let i = 0; i < data.length; i += 8) {
+			const block = data.subarray(i, i + 8);
+			res += base58.encode(block).padStart(XMR_BLOCK_LEN[block.length], "1");
+		}
+		return res;
+	},
+	decode(str) {
+		let res = [];
+		for (let i = 0; i < str.length; i += 11) {
+			const slice = str.slice(i, i + 11);
+			const blockLen = XMR_BLOCK_LEN.indexOf(slice.length);
+			const block = base58.decode(slice);
+			for (let j = 0; j < block.length - blockLen; j++) if (block[j] !== 0) throw new Error("base58xmr: wrong padding");
+			res = res.concat(Array.from(block.slice(block.length - blockLen)));
+		}
+		return Uint8Array.from(res);
+	}
+};
+const createBase58check = (sha256) => chain(checksum(4, (data) => sha256(sha256(data))), base58);
+const base58check = createBase58check;
+const BECH_ALPHABET = /* @__PURE__ */ chain(alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), join(""));
+const POLYMOD_GENERATORS = [
+	996825010,
+	642813549,
+	513874426,
+	1027748829,
+	705979059
+];
+/**
+* @__NO_SIDE_EFFECTS__
+*/
+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;
+}
+/**
+* @__NO_SIDE_EFFECTS__
+*/
+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 % 2 ** 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) {
+		if (typeof prefix !== "string") throw new Error(`bech32.encode prefix should be string, not ${typeof prefix}`);
+		if (words instanceof Uint8Array) words = Array.from(words);
+		if (!Array.isArray(words) || words.length && typeof words[0] !== "number") throw new Error(`bech32.encode words should be array of numbers, not ${typeof words}`);
+		if (prefix.length === 0) throw new TypeError(`Invalid prefix length ${prefix.length}`);
+		const actualLength = prefix.length + 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) {
+		if (typeof str !== "string") throw new Error(`bech32.decode input should be string, not ${typeof str}`);
+		if (str.length < 8 || limit !== false && str.length > limit) throw new TypeError(`Wrong string length: ${str.length} (${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
+	};
+}
+const bech32 = /* @__PURE__ */ genBech32("bech32");
+const bech32m = /* @__PURE__ */ genBech32("bech32m");
+const utf8 = {
+	encode: (data) => Uint8ArrayToString(data),
+	decode: (str) => stringToUInt8Array(str)
+};
+const hex = /* @__PURE__ */ chain(radix2(4), alphabet("0123456789abcdef"), join(""), normalize((s) => {
+	if (typeof s !== "string" || s.length % 2) throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
+	return s.toLowerCase();
+}));
+const CODERS = {
+	utf8,
+	hex,
+	base16,
+	base32,
+	base64,
+	base64url,
+	base58,
+	base58xmr
+};
+const coderTypeError = "Invalid encoding type. Available types: utf8, hex, base16, base32, base64, base64url, base58, base58xmr";
+const bytesToString = (type, bytes) => {
+	if (typeof type !== "string" || !CODERS.hasOwnProperty(type)) throw new TypeError(coderTypeError);
+	if (!isBytes(bytes)) throw new TypeError("bytesToString() expects Uint8Array");
+	return CODERS[type].encode(bytes);
+};
+const str = bytesToString;
+const stringToBytes = (type, str) => {
+	if (!CODERS.hasOwnProperty(type)) throw new TypeError(coderTypeError);
+	if (typeof str !== "string") throw new TypeError("stringToBytes() expects string");
+	return CODERS[type].decode(str);
+};
+const bytes = stringToBytes;
+
+//#endregion
+//#region src/common/data/bin.ts
+function _encodeUtf8Polyfill(str) {
+	const encodedString = unescape(encodeURIComponent(str));
+	const len = encodedString.length;
+	const buf = new Uint8Array(len);
+	for (let i = 0; i < len; i++) buf[i] = encodedString.codePointAt(i) || 0;
+	return buf;
+}
+function _decodeUtf8Polyfill(buf) {
+	let remainingLen = buf.length;
+	let encodedString = "";
+	let bufPos = 0;
+	while (remainingLen > 0) {
+		const nextLen = remainingLen < 1e4 ? remainingLen : 1e4;
+		const bytes = buf.subarray(bufPos, bufPos + nextLen);
+		bufPos += nextLen;
+		encodedString += String.fromCodePoint.apply(null, bytes);
+		remainingLen -= nextLen;
+	}
+	return decodeURIComponent(escape(encodedString));
+}
+let _textEncoder;
+function stringToUInt8Array(text) {
+	if (_textEncoder == null) {
+		_textEncoder = _encodeUtf8Polyfill;
+		if (typeof TextEncoder !== "undefined") {
+			const encoder = new TextEncoder();
+			_textEncoder = (data) => encoder.encode(data);
+		}
+	}
+	return _textEncoder(text.normalize("NFC"));
+}
+let _textDecoder;
+function Uint8ArrayToString(bin) {
+	if (_textDecoder == null) {
+		_textDecoder = _decodeUtf8Polyfill;
+		if (typeof TextDecoder !== "undefined") {
+			const decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+			_textDecoder = (data) => decoder.decode(data);
+		}
+	}
+	return _textDecoder(bin).normalize("NFC");
+}
+function toArrayBuffer(bin) {
+	const b = toUint8Array(bin);
+	if (b.buffer.byteLength === b.byteLength) return b.buffer;
+	return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+}
+function toUint8Array(data) {
+	if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	if (typeof data === "string") return stringToUInt8Array(data);
+	if (data.length) return new Uint8Array(data);
+	return data;
+}
+/**
+* Ensures a Uint8Array is backed by a real ArrayBuffer (not SharedArrayBuffer).
+* This is needed for Web Crypto API compatibility which requires BufferSource with ArrayBuffer.
+*/
+function ensureUint8Array(data) {
+	if (data.buffer instanceof ArrayBuffer) return data;
+	return new Uint8Array(data);
+}
+function joinToUint8Array(...args) {
+	let length = 0;
+	const bins = args.flat(1).map((d) => {
+		const b = toUint8Array(d);
+		length += b.length;
+		return b;
+	});
+	const bin = new Uint8Array(length);
+	let cursor = 0;
+	for (const b of bins) {
+		bin.set(b, cursor);
+		cursor += b.length;
+	}
+	return bin;
+}
+function toHex(bin) {
+	if (typeof Buffer !== "undefined") return Buffer.from(toUint8Array(bin)).toString("hex");
+	const h = "0123456789abcdef";
+	let s = "";
+	for (const v of [...toUint8Array(bin)]) s += h[v >> 4] + h[v & 15];
+	return s;
+}
+function fromHex(hexString) {
+	return Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => Number.parseInt(byte, 16)));
+}
+/** Regular base64 */
+function toBase64(bin, stripPadding = false) {
+	const bytes = toUint8Array(bin);
+	let sb = "";
+	if (typeof Buffer !== "undefined") {
+		sb = Buffer.from(bytes).toString("base64");
+		if (stripPadding) return sb.replace(/\=/g, "");
+		return sb;
+	}
+	if (stripPadding) return base64nopad.encode(bytes);
+	return base64.encode(bytes);
+}
+/** Converts `+` -> `-` and `/` -> `_`. Always strips `=` */
+function toBase64Url(bin) {
+	const bytes = toUint8Array(bin);
+	if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64url").replace(/\=/g, "");
+	return base64urlnopad.encode(bytes);
+}
+/** Also parses toBase64Url encoded strings. */
+function fromBase64(s) {
+	s = s.replace(/\-/g, "+").replace(/\_/g, "/");
+	if (typeof Buffer !== "undefined") {
+		const buf = Buffer.from(s, "base64");
+		return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+	}
+	if (typeof atob !== "undefined") {
+		const a = atob(s);
+		const bytes = new Uint8Array(a.length);
+		for (let i = 0; i < a.length; i++) bytes[i] = a.charCodeAt(i);
+		return bytes;
+	}
+	return base64.decode(s);
+}
+/** Also parses toBase64Url encoded strings. */
+function fromBase64String(s) {
+	return Uint8ArrayToString(fromBase64(s));
+}
+/** Compare contents of binary arrays */
+function equalBinary(a, b) {
+	if (a.byteLength !== b.byteLength) return false;
+	const aa = toUint8Array(a);
+	const bb = toUint8Array(b);
+	for (let i = 0; i < aa.length; i++) if (aa[i] !== bb[i]) return false;
+	return true;
+}
+function jsonToUint8Array(json) {
+	return stringToUInt8Array(jsonStringifySafe(json));
+}
+function Uint8ArrayToJson(data) {
+	return JSON.parse(Uint8ArrayToString(data));
+}
+function Uint8ArrayToHexDump(buffer, blockSize) {
+	if (typeof buffer === "string") {} else if (buffer instanceof ArrayBuffer && buffer.byteLength !== void 0) buffer = String.fromCharCode.apply(String, [].slice.call(new Uint8Array(buffer)));
+	else if (Array.isArray(buffer)) buffer = String.fromCharCode.apply(String, buffer);
+	else if (buffer.constructor === Uint8Array) buffer = String.fromCharCode.apply(String, [].slice.call(buffer));
+	else return false;
+	blockSize = blockSize || 16;
+	const lines = [];
+	const hex = "0123456789abcdef";
+	for (let b = 0; b < buffer.length; b += blockSize) {
+		const block = buffer.slice(b, Math.min(b + blockSize, buffer.length));
+		const addr = `0000${b.toString(16)}`.slice(-4);
+		let codes = block.split("").map((ch) => {
+			const code = ch.charCodeAt(0);
+			return ` ${hex[(240 & code) >> 4]}${hex[15 & code]}`;
+		}).join("");
+		codes += "   ".repeat(blockSize - block.length);
+		let chars = block.replace(/[\x00-\x1F\x20\x7F-\xA0\xAD]/g, ".");
+		chars += " ".repeat(blockSize - block.length);
+		lines.push(`${addr} ${codes}  ${chars}`);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+export { base58xmr as A, createBase58check as B, base32crockford as C, base58 as D, base32nopad as E, base64urlnopad as F, utils as G, str as H, bech32 as I, bech32m as L, base64 as M, base64nopad as N, base58check as O, base64url as P, bytes as R, base32agnoster as S, base32hexnopad as T, stringToBytes as U, hex as V, utf8 as W, toHex as _, _encodeUtf8Polyfill as a, base16 as b, fromBase64 as c, joinToUint8Array as d, jsonToUint8Array as f, toBase64Url as g, toBase64 as h, _decodeUtf8Polyfill as i, base58xrp as j, base58flickr as k, fromBase64String as l, toArrayBuffer as m, Uint8ArrayToJson as n, ensureUint8Array as o, stringToUInt8Array as p, Uint8ArrayToString as r, equalBinary as s, Uint8ArrayToHexDump as t, fromHex as u, toUint8Array as v, base32hex as w, base32 as x, assertNumber as y, bytesToString as z };
+//# sourceMappingURL=bin-BAoS4qtm.mjs.map