zeed 1.3.0 → 1.4.0

package/dist/bin-Ddaz2lxM.cjs

@@ -0,0 +1,862 @@
+const require_common_data_json = require('./common/data/json.cjs');
+
+//#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(require_common_data_json.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
+Object.defineProperty(exports, 'Uint8ArrayToHexDump', {
+  enumerable: true,
+  get: function () {
+    return Uint8ArrayToHexDump;
+  }
+});
+Object.defineProperty(exports, 'Uint8ArrayToJson', {
+  enumerable: true,
+  get: function () {
+    return Uint8ArrayToJson;
+  }
+});
+Object.defineProperty(exports, 'Uint8ArrayToString', {
+  enumerable: true,
+  get: function () {
+    return Uint8ArrayToString;
+  }
+});
+Object.defineProperty(exports, '_decodeUtf8Polyfill', {
+  enumerable: true,
+  get: function () {
+    return _decodeUtf8Polyfill;
+  }
+});
+Object.defineProperty(exports, '_encodeUtf8Polyfill', {
+  enumerable: true,
+  get: function () {
+    return _encodeUtf8Polyfill;
+  }
+});
+Object.defineProperty(exports, 'assertNumber', {
+  enumerable: true,
+  get: function () {
+    return assertNumber;
+  }
+});
+Object.defineProperty(exports, 'base16', {
+  enumerable: true,
+  get: function () {
+    return base16;
+  }
+});
+Object.defineProperty(exports, 'base32', {
+  enumerable: true,
+  get: function () {
+    return base32;
+  }
+});
+Object.defineProperty(exports, 'base32agnoster', {
+  enumerable: true,
+  get: function () {
+    return base32agnoster;
+  }
+});
+Object.defineProperty(exports, 'base32crockford', {
+  enumerable: true,
+  get: function () {
+    return base32crockford;
+  }
+});
+Object.defineProperty(exports, 'base32hex', {
+  enumerable: true,
+  get: function () {
+    return base32hex;
+  }
+});
+Object.defineProperty(exports, 'base32hexnopad', {
+  enumerable: true,
+  get: function () {
+    return base32hexnopad;
+  }
+});
+Object.defineProperty(exports, 'base32nopad', {
+  enumerable: true,
+  get: function () {
+    return base32nopad;
+  }
+});
+Object.defineProperty(exports, 'base58', {
+  enumerable: true,
+  get: function () {
+    return base58;
+  }
+});
+Object.defineProperty(exports, 'base58check', {
+  enumerable: true,
+  get: function () {
+    return base58check;
+  }
+});
+Object.defineProperty(exports, 'base58flickr', {
+  enumerable: true,
+  get: function () {
+    return base58flickr;
+  }
+});
+Object.defineProperty(exports, 'base58xmr', {
+  enumerable: true,
+  get: function () {
+    return base58xmr;
+  }
+});
+Object.defineProperty(exports, 'base58xrp', {
+  enumerable: true,
+  get: function () {
+    return base58xrp;
+  }
+});
+Object.defineProperty(exports, 'base64', {
+  enumerable: true,
+  get: function () {
+    return base64;
+  }
+});
+Object.defineProperty(exports, 'base64nopad', {
+  enumerable: true,
+  get: function () {
+    return base64nopad;
+  }
+});
+Object.defineProperty(exports, 'base64url', {
+  enumerable: true,
+  get: function () {
+    return base64url;
+  }
+});
+Object.defineProperty(exports, 'base64urlnopad', {
+  enumerable: true,
+  get: function () {
+    return base64urlnopad;
+  }
+});
+Object.defineProperty(exports, 'bech32', {
+  enumerable: true,
+  get: function () {
+    return bech32;
+  }
+});
+Object.defineProperty(exports, 'bech32m', {
+  enumerable: true,
+  get: function () {
+    return bech32m;
+  }
+});
+Object.defineProperty(exports, 'bytes', {
+  enumerable: true,
+  get: function () {
+    return bytes;
+  }
+});
+Object.defineProperty(exports, 'bytesToString', {
+  enumerable: true,
+  get: function () {
+    return bytesToString;
+  }
+});
+Object.defineProperty(exports, 'createBase58check', {
+  enumerable: true,
+  get: function () {
+    return createBase58check;
+  }
+});
+Object.defineProperty(exports, 'ensureUint8Array', {
+  enumerable: true,
+  get: function () {
+    return ensureUint8Array;
+  }
+});
+Object.defineProperty(exports, 'equalBinary', {
+  enumerable: true,
+  get: function () {
+    return equalBinary;
+  }
+});
+Object.defineProperty(exports, 'fromBase64', {
+  enumerable: true,
+  get: function () {
+    return fromBase64;
+  }
+});
+Object.defineProperty(exports, 'fromBase64String', {
+  enumerable: true,
+  get: function () {
+    return fromBase64String;
+  }
+});
+Object.defineProperty(exports, 'fromHex', {
+  enumerable: true,
+  get: function () {
+    return fromHex;
+  }
+});
+Object.defineProperty(exports, 'hex', {
+  enumerable: true,
+  get: function () {
+    return hex;
+  }
+});
+Object.defineProperty(exports, 'joinToUint8Array', {
+  enumerable: true,
+  get: function () {
+    return joinToUint8Array;
+  }
+});
+Object.defineProperty(exports, 'jsonToUint8Array', {
+  enumerable: true,
+  get: function () {
+    return jsonToUint8Array;
+  }
+});
+Object.defineProperty(exports, 'str', {
+  enumerable: true,
+  get: function () {
+    return str;
+  }
+});
+Object.defineProperty(exports, 'stringToBytes', {
+  enumerable: true,
+  get: function () {
+    return stringToBytes;
+  }
+});
+Object.defineProperty(exports, 'stringToUInt8Array', {
+  enumerable: true,
+  get: function () {
+    return stringToUInt8Array;
+  }
+});
+Object.defineProperty(exports, 'toArrayBuffer', {
+  enumerable: true,
+  get: function () {
+    return toArrayBuffer;
+  }
+});
+Object.defineProperty(exports, 'toBase64', {
+  enumerable: true,
+  get: function () {
+    return toBase64;
+  }
+});
+Object.defineProperty(exports, 'toBase64Url', {
+  enumerable: true,
+  get: function () {
+    return toBase64Url;
+  }
+});
+Object.defineProperty(exports, 'toHex', {
+  enumerable: true,
+  get: function () {
+    return toHex;
+  }
+});
+Object.defineProperty(exports, 'toUint8Array', {
+  enumerable: true,
+  get: function () {
+    return toUint8Array;
+  }
+});
+Object.defineProperty(exports, 'utf8', {
+  enumerable: true,
+  get: function () {
+    return utf8;
+  }
+});
+Object.defineProperty(exports, 'utils', {
+  enumerable: true,
+  get: function () {
+    return utils;
+  }
+});
+//# sourceMappingURL=bin-Ddaz2lxM.cjs.map