@cbortech/cbor 0.23.0 → 0.24.0

package/dist/mapEntries-D5MWtXqq.js

@@ -0,0 +1,3245 @@
+//#region src/tag.ts
+var e = Symbol.for("cbor.tag"), t = class {
+	valueOf() {
+		return null;
+	}
+	toJSON() {
+		return null;
+	}
+}, n = class {
+	valueOf() {}
+	toJSON() {}
+};
+function r(t) {
+	if (!s(t)) return;
+	let n = t[e];
+	return typeof n == "bigint" ? n : void 0;
+}
+function i(r, i) {
+	let a;
+	switch (typeof r) {
+		case "number":
+			a = new Number(r);
+			break;
+		case "string":
+			a = new String(r);
+			break;
+		case "boolean":
+			a = new Boolean(r);
+			break;
+		case "bigint":
+			a = Object(r);
+			break;
+		case "undefined":
+			a = new n();
+			break;
+		case "object":
+			if (r === null) {
+				a = new t();
+				break;
+			}
+			a = r;
+			break;
+		default: throw TypeError(`setCborTag: cannot tag value of type ${typeof r}`);
+	}
+	return a[e] = i, a;
+}
+function a(r) {
+	if (r instanceof Number || r instanceof String || r instanceof Boolean || Object.prototype.toString.call(r) === "[object BigInt]") return r.valueOf();
+	if (r instanceof t) return null;
+	if (!(r instanceof n)) return typeof r == "object" && r && delete r[e], r;
+}
+function o(e) {
+	if (e instanceof Number || e instanceof String || e instanceof Boolean || Object.prototype.toString.call(e) === "[object BigInt]") return e.valueOf();
+	if (e instanceof t) return null;
+	if (!(e instanceof n)) return e;
+}
+function s(e) {
+	return typeof e == "object" && !!e;
+}
+var c = class {
+	constructor() {}
+	static symbol = e;
+	static Null = t;
+	static Undefined = n;
+	static get(e) {
+		return r(e);
+	}
+	static set(e, t) {
+		return i(e, t);
+	}
+	static remove(e) {
+		return a(e);
+	}
+	static getValue(e) {
+		return o(e);
+	}
+}, l = Symbol("cbor.omit"), u = class e {
+	value;
+	constructor(e) {
+		if (!Number.isInteger(e) || e < 0 || e > 255) throw RangeError("Simple value must be an integer in 0–255");
+		this.value = e;
+	}
+	valueOf() {
+		return this.value;
+	}
+	toJSON() {
+		throw TypeError(`simple(${this.value}) cannot be serialized to JSON`);
+	}
+	static is(t) {
+		return t instanceof e;
+	}
+	static get(t) {
+		return t instanceof e ? t.value : void 0;
+	}
+}, d = class {
+	start;
+	end;
+	comments;
+	_defaults;
+	toCBOR(e) {
+		let t = this._defaults ? {
+			...this._defaults,
+			...e
+		} : e;
+		return this._toCBOR(t);
+	}
+	toEDN(e) {
+		let t = this._defaults ? {
+			...this._defaults,
+			...e
+		} : e, n = this._toEDN(t, 0);
+		if (!t?.preserveComments) return n;
+		let r = this.comments?.leading?.map((e) => e.text) ?? [], i = this.comments?.trailing ?? [], a = i.length === 0 ? n : `${n} ${i.map((e) => e.text.trimEnd()).join(" ")}`;
+		return [...r, a].join("\n");
+	}
+	toJS(e) {
+		let t = this._defaults ? {
+			...this._defaults,
+			...e
+		} : e, n = this._toJS(t);
+		if (!t?.reviver) return n;
+		let r = t.reviver.call({ "": n }, "", n);
+		return r === l ? void 0 : r;
+	}
+	toHexDump(e) {
+		let t = this._defaults ? {
+			...this._defaults,
+			...e
+		} : e, n = t?.indent ?? 3, r = typeof n == "string" ? n : " ".repeat(n), i = (t?.commentStyle ?? "--") + " ", a = this._toHexDump(0, t), o = Math.max(...a.map((e) => e.depth * r.length + e.hex.length)) + 2;
+		return a.map((e) => (r.repeat(e.depth) + e.hex).padEnd(o) + i + e.comment).join("\n");
+	}
+	_toHexDump(e, t) {
+		return [{
+			depth: e,
+			hex: Array.from(this._toCBOR(), (e) => e.toString(16).toUpperCase().padStart(2, "0")).join(" "),
+			comment: this._toEDN(t, 0)
+		}];
+	}
+}, f = "getFloat16" in DataView.prototype && "setFloat16" in DataView.prototype, p = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+function ee(e) {
+	p.setFloat64(0, e, !1);
+	let t = p.getUint32(0, !1), n = p.getUint32(4, !1), r = t >>> 31 & 1, i = t >>> 20 & 2047, a = t & 1048575;
+	if (i === 2047) {
+		if (a === 0 && n === 0) return r << 15 | 31744;
+		let e = a >> 10 | (n === 0 ? 0 : 1) || 1;
+		return r << 15 | 31744 | e & 1023;
+	}
+	let o = i - 1023 + 15;
+	if (o >= 31) return r << 15 | 31744;
+	let s, c, l;
+	if (o <= 0) {
+		if (o < -10) return r << 15;
+		let e = 1 << 20 | a, t = 11 - o;
+		t <= 20 ? (s = e >> t & 1023, c = e >> t - 1 & 1, l = (e & (1 << t - 1) - 1) != 0 || n !== 0) : (s = 0, c = 1, l = a !== 0 || n !== 0);
+	} else s = a >> 10, c = a >> 9 & 1, l = (a & 511) != 0 || n !== 0;
+	if (c !== 0 && (l || s & 1) && s++, s >= 1024) {
+		let e = o <= 0 ? 1 : o + 1;
+		return e >= 31 ? r << 15 | 31744 : r << 15 | e << 10;
+	}
+	let u = o <= 0 ? 0 : o;
+	return r << 15 | u << 10 | s;
+}
+function te(e) {
+	let t = e >>> 15 & 1, n = e >>> 10 & 31, r = e & 1023;
+	return n === 31 ? r === 0 ? t ? -Infinity : Infinity : NaN : n === 0 ? r === 0 ? t ? -0 : 0 : (t ? -1 : 1) * 2 ** -14 * (r / 1024) : (t ? -1 : 1) * 2 ** (n - 15) * (1 + r / 1024);
+}
+var ne = f ? (e, t, n, r) => {
+	e.setFloat16(t, n, r);
+} : (e, t, n, r) => {
+	e.setUint16(t, ee(n), r);
+};
+//#endregion
+//#region src/cbor/encode.ts
+function m(e, t, n) {
+	if (n !== void 0) {
+		if (n === "i") {
+			if (t > 23n) throw RangeError(`value ${t} does not fit in immediate encoding _i (max 23)`);
+			return new Uint8Array([e << 5 | Number(t)]);
+		}
+		let r = [
+			255n,
+			65535n,
+			4294967295n,
+			18446744073709551615n
+		];
+		if (t > r[n]) throw RangeError(`value ${t} does not fit in encodingWidth _${n} (max ${r[n]})`);
+		let i = 24 + n;
+		if (i === 24) return new Uint8Array([e << 5 | 24, Number(t)]);
+		if (i === 25) {
+			let n = new Uint8Array(3);
+			return n[0] = e << 5 | 25, n[1] = Number(t >> 8n), n[2] = Number(t & 255n), n;
+		}
+		if (i === 26) {
+			let n = new Uint8Array(5);
+			return n[0] = e << 5 | 26, new DataView(n.buffer).setUint32(1, Number(t), !1), n;
+		}
+		let a = new Uint8Array(9);
+		return a[0] = e << 5 | 27, new DataView(a.buffer).setBigUint64(1, t, !1), a;
+	}
+	if (t <= 23n) return new Uint8Array([e << 5 | Number(t)]);
+	if (t <= 255n) return new Uint8Array([e << 5 | 24, Number(t)]);
+	if (t <= 65535n) {
+		let n = new Uint8Array(3);
+		return n[0] = e << 5 | 25, n[1] = Number(t >> 8n), n[2] = Number(t & 255n), n;
+	}
+	if (t <= 4294967295n) {
+		let n = new Uint8Array(5);
+		return n[0] = e << 5 | 26, new DataView(n.buffer).setUint32(1, Number(t), !1), n;
+	}
+	let r = new Uint8Array(9);
+	return r[0] = e << 5 | 27, new DataView(r.buffer).setBigUint64(1, t, !1), r;
+}
+function h(e) {
+	let t = e.reduce((e, t) => e + t.length, 0), n = new Uint8Array(t), r = 0;
+	for (let t of e) n.set(t, r), r += t.length;
+	return n;
+}
+var re = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4));
+function ie(e) {
+	return Object.is(te(ee(e)), e);
+}
+function ae(e) {
+	return re.setFloat32(0, e, !1), Object.is(re.getFloat32(0, !1), e);
+}
+function oe(e) {
+	return ie(e) ? "half" : ae(e) ? "single" : "double";
+}
+//#endregion
+//#region src/ast/CborUint.ts
+var g = class extends d {
+	value;
+	encodingWidth;
+	constructor(e, t) {
+		if (super(), this.value = BigInt(e), this.value < 0n) throw RangeError("CborUint value must be non-negative");
+		if (this.value > 18446744073709551615n) throw RangeError("CborUint value exceeds maximum uint64");
+		this.encodingWidth = t?.encodingWidth;
+	}
+	_toCBOR(e) {
+		return m(0, this.value, this.encodingWidth);
+	}
+	_toEDN(e, t) {
+		let n = this.encodingWidth === void 0 ? "" : `_${this.encodingWidth}`, r = this.value;
+		switch (e?.intFormat) {
+			case "hex": return `0x${r.toString(16)}${n}`;
+			case "octal": return `0o${r.toString(8)}${n}`;
+			case "binary": return `0b${r.toString(2)}${n}`;
+			default: return r.toString() + n;
+		}
+	}
+	_toJS(e) {
+		let t = e?.integerAs ?? "auto";
+		return t === "bigint" ? this.value : t === "number" || this.value <= BigInt(2 ** 53 - 1) ? Number(this.value) : this.value;
+	}
+}, _ = class extends d {
+	argument;
+	encodingWidth;
+	constructor(e, t) {
+		super();
+		let n = BigInt(e);
+		if (n >= 0n) throw RangeError("CborNint value must be negative");
+		if (n < -18446744073709551616n) throw RangeError("CborNint value exceeds minimum int64");
+		this.argument = -1n - n, this.encodingWidth = t?.encodingWidth;
+	}
+	get value() {
+		return -1n - this.argument;
+	}
+	_toCBOR(e) {
+		return m(1, this.argument, this.encodingWidth);
+	}
+	_toEDN(e, t) {
+		let n = this.encodingWidth === void 0 ? "" : `_${this.encodingWidth}`, r = this.argument + 1n;
+		switch (e?.intFormat) {
+			case "hex": return `-0x${r.toString(16)}${n}`;
+			case "octal": return `-0o${r.toString(8)}${n}`;
+			case "binary": return `-0b${r.toString(2)}${n}`;
+			default: return this.value.toString() + n;
+		}
+	}
+	_toJS(e) {
+		let t = this.value, n = e?.integerAs ?? "auto";
+		return n === "bigint" ? t : n === "number" || t >= BigInt(-(2 ** 53 - 1)) ? Number(t) : t;
+	}
+};
+//#endregion
+//#region src/edn/serialize-utils.ts
+function v(e) {
+	let t = e?.indent;
+	return t === void 0 ? null : typeof t == "number" ? " ".repeat(t) : t;
+}
+function y(e, t) {
+	return e.repeat(t);
+}
+function b(e) {
+	return !!(e.comments?.leading?.length || e.comments?.trailing?.length || e.comments?.dangling?.length);
+}
+function se(e) {
+	return !!(e.comments?.trailing?.length || e.comments?.dangling?.length);
+}
+function ce(e, t) {
+	return (e.comments?.leading ?? []).map((e) => t + e.text);
+}
+function le(e) {
+	let t = e.comments?.trailing ?? [];
+	return t.length === 0 ? "" : " " + t.map((e) => e.text).join(" ");
+}
+function ue(e, t) {
+	return (e.comments?.dangling ?? []).map((e) => t + e.text);
+}
+function x(e, t = !1) {
+	let n = e?.commas ?? "comma", r = n !== "none";
+	return {
+		inlineSep: r ? t ? "," : ", " : " ",
+		multilineSep: r ? "," : "",
+		trailSep: n === "trailing" ? "," : "",
+		colSep: t ? ":" : ": "
+	};
+}
+function de(e) {
+	return typeof e.toHex == "function" ? e.toHex() : Array.from(e, (e) => e.toString(16).padStart(2, "0")).join("");
+}
+var fe = typeof new Uint8Array().toBase64 == "function";
+function pe(e) {
+	if (fe) return e.toBase64({ omitPadding: !0 });
+	let t = "";
+	for (let n of e) t += String.fromCharCode(n);
+	return btoa(t).replace(/=/g, "");
+}
+function me(e) {
+	if (fe) return e.toBase64({
+		alphabet: "base64url",
+		omitPadding: !0
+	});
+	let t = "";
+	for (let n of e) t += String.fromCharCode(n);
+	return btoa(t).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+var he = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", ge = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+function _e(e, t) {
+	let n = "", r = 0, i = 0;
+	for (let a of e) for (r = r << 8 | a, i += 8; i >= 5;) i -= 5, n += t[r >> i & 31];
+	return i > 0 && (n += t[r << 5 - i & 31]), n;
+}
+function ve(e) {
+	for (let t of e) {
+		let e = t.codePointAt(0);
+		if (e < 32 || e === 127) return !0;
+	}
+	return !1;
+}
+function ye(e, t, n) {
+	if (n === "string") {
+		let t = be(e);
+		if (t != null) return Se(t);
+	}
+	if (n === "printable-string" || n === void 0) {
+		let t = be(e);
+		if (t != null && !ve(t)) return Se(t);
+	}
+	switch (t) {
+		case "base64": return `b64'${pe(e)}'`;
+		case "base64url": return `b64'${me(e)}'`;
+		case "base32": return `b32'${_e(e, he)}'`;
+		case "base32hex": return `h32'${_e(e, ge)}'`;
+		default: return `h'${de(e)}'`;
+	}
+}
+function be(e) {
+	try {
+		return new TextDecoder("utf-8", { fatal: !0 }).decode(e);
+	} catch {
+		return null;
+	}
+}
+function xe(e, t) {
+	let n = t.codePointAt(0), r = t;
+	for (let i of e) {
+		let e = i.codePointAt(0);
+		switch (e) {
+			case n:
+				r += `\\${t}`;
+				break;
+			case 92:
+				r += "\\\\";
+				break;
+			case 10:
+				r += "\\n";
+				break;
+			case 13:
+				r += "\\r";
+				break;
+			case 9:
+				r += "\\t";
+				break;
+			default: e < 32 || e === 127 || e === 8232 || e === 8233 || e === 8203 || e === 8204 || e === 8205 || e === 65279 ? r += `\\u${e.toString(16).padStart(4, "0")}` : r += i;
+		}
+	}
+	return r + t;
+}
+function Se(e) {
+	return xe(e, "'");
+}
+function Ce(e) {
+	return xe(e, "'");
+}
+function we(e) {
+	return xe(e, "\"");
+}
+function Te(e) {
+	if (isNaN(e)) return "NaN";
+	if (!isFinite(e)) return e > 0 ? "Infinity" : "-Infinity";
+	if (Object.is(e, -0)) return "-0.0";
+	let t = e.toString();
+	return t.includes(".") || t.includes("e") ? t : t + ".0";
+}
+function Ee(e, t, n) {
+	return t === void 0 || t === n ? "" : t === "half" ? "_1" : t === "single" ? "_2" : "_3";
+}
+//#endregion
+//#region src/utils/hexfloat.ts
+var De = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+function Oe(e) {
+	let t = e.startsWith("-"), n = e.slice(t ? 3 : 2), r = n.search(/[pP]/);
+	if (r === -1) throw SyntaxError(`EDN parse error: hex float missing 'p' exponent: ${e}`);
+	let i = n.slice(0, r), a = n.slice(r + 1);
+	if (!/^[+-]?\d+$/.test(a)) throw SyntaxError(`EDN parse error: hex float has invalid or missing exponent: ${e}`);
+	let o = parseInt(a, 10), s = i.indexOf("."), c;
+	if (s === -1) {
+		if (!/^[0-9a-fA-F]+$/.test(i)) throw SyntaxError(`EDN parse error: hex float has no mantissa digits: ${e}`);
+		c = parseInt(i, 16);
+	} else {
+		let t = i.slice(0, s), n = i.slice(s + 1);
+		if (t === "" && n === "") throw SyntaxError(`EDN parse error: hex float has no mantissa digits: ${e}`);
+		if (t !== "" && !/^[0-9a-fA-F]+$/.test(t) || n !== "" && !/^[0-9a-fA-F]+$/.test(n)) throw SyntaxError(`EDN parse error: hex float has invalid mantissa: ${e}`);
+		c = (t === "" ? 0 : parseInt(t, 16)) + (n === "" ? 0 : parseInt(n, 16) / 16 ** n.length);
+	}
+	let l = c * 2 ** o;
+	return t ? -l : l;
+}
+function ke(e) {
+	if (isNaN(e)) return "NaN";
+	if (!isFinite(e)) return e > 0 ? "Infinity" : "-Infinity";
+	let t = Object.is(e, -0) || e < 0, n = Math.abs(e);
+	if (n === 0) return t ? "-0x0p+0" : "0x0p+0";
+	De.setFloat64(0, n, !1);
+	let r = De.getUint32(0, !1), i = De.getUint32(4, !1), a = r >>> 20 & 2047, o = r & 1048575, s = i, c = (o.toString(16).padStart(5, "0") + s.toString(16).padStart(8, "0")).replace(/0+$/, ""), l = c === "" ? "" : `.${c}`, u, d;
+	a === 0 ? (u = "0", d = -1022) : (u = "1", d = a - 1023);
+	let f = d >= 0 ? `+${d}` : `${d}`, p = `0x${u}${l}p${f}`;
+	return t ? `-${p}` : p;
+}
+//#endregion
+//#region src/ast/CborFloat.ts
+var S = class extends d {
+	value;
+	precision;
+	constructor(e, t) {
+		super(), this.value = e, this.precision = t?.precision;
+	}
+	_toCBOR(e) {
+		let t = this.precision ?? oe(this.value);
+		if (t === "half") {
+			let e = new Uint8Array(3);
+			return e[0] = 249, ne(new DataView(e.buffer), 1, this.value, !1), e;
+		}
+		if (t === "single") {
+			let e = new Uint8Array(5);
+			return e[0] = 250, new DataView(e.buffer).setFloat32(1, this.value, !1), e;
+		}
+		let n = new Uint8Array(9);
+		return n[0] = 251, new DataView(n.buffer).setFloat64(1, this.value, !1), n;
+	}
+	_toEDN(e, t) {
+		let n = oe(this.value);
+		return (e?.floatFormat === "hex" ? ke(this.value) : Te(this.value)) + Ee(this.value, this.precision, n);
+	}
+	_toJS(e) {
+		return this.value;
+	}
+}, C = class extends d {
+	tag;
+	content;
+	encodingWidth;
+	constructor(e, t, n) {
+		if (super(), this.tag = BigInt(e), this.tag < 0n) throw RangeError("CborTag tag number must be non-negative");
+		this.content = t, this.encodingWidth = n?.encodingWidth;
+	}
+	_toCBOR(e) {
+		return h([m(6, this.tag, this.encodingWidth), this.content._toCBOR(e)]);
+	}
+	_toEDN(e, t) {
+		let n = this.encodingWidth === void 0 ? "" : `_${this.encodingWidth}`;
+		return `${this.tag}${n}(${this.content._toEDN(e, t)})`;
+	}
+	_toHexDump(e, t) {
+		let n = [{
+			depth: e,
+			hex: ((e) => Array.from(e, (e) => e.toString(16).toUpperCase().padStart(2, "0")).join(" "))(m(6, this.tag, this.encodingWidth)),
+			comment: `Tag ${this.tag}`
+		}];
+		return n.push(...this.content._toHexDump(e + 1, t)), n;
+	}
+	_toJS(e) {
+		let t = this.content._toJS(e);
+		return e?.stripTags ? t : c.set(t, this.tag);
+	}
+};
+//#endregion
+//#region src/edn/tokenizer.ts
+function Ae(e, t) {
+	let n = 1, r = 1;
+	for (let i = 0; i < t; i++) e[i] === "\n" ? (n++, r = 1) : r++;
+	return {
+		line: n,
+		col: r
+	};
+}
+var je = class {
+	input;
+	pos;
+	line;
+	col;
+	_peeked = null;
+	_lastConsumedEndOffset;
+	comments = [];
+	constructor(e, t) {
+		this.input = e;
+		let n = t?.offset ?? 0;
+		if (!Number.isInteger(n) || n < 0 || n > e.length) throw RangeError(`EDN parse offset must be an integer between 0 and ${e.length}`);
+		let r = Ae(e, n);
+		this.pos = n, this.line = r.line, this.col = r.col, this._lastConsumedEndOffset = n;
+	}
+	peek() {
+		return this._peeked === null && (this._peeked = this._readNext()), this._peeked;
+	}
+	consume() {
+		let e = this._peeked === null ? this._readNext() : this._peeked;
+		return this._peeked = null, this._lastConsumedEndOffset = e.endOffset, e;
+	}
+	get lastEndOffset() {
+		return this._lastConsumedEndOffset;
+	}
+	_ch() {
+		return this.input[this.pos] ?? "";
+	}
+	_eof() {
+		return this.pos >= this.input.length;
+	}
+	_advance() {
+		let e = this.input[this.pos++] ?? "";
+		return e === "\n" ? (this.line++, this.col = 1) : this.col++, e;
+	}
+	_fail(e, t = this.line, n = this.col) {
+		throw SyntaxError(`EDN parse error at line ${t}, column ${n}: ${e}`);
+	}
+	_skipWS() {
+		for (;;) {
+			for (; !this._eof() && /\s/.test(this._ch());) this._advance();
+			if (this._eof()) return;
+			let e = this._ch();
+			if (e === "#") {
+				let e = this.pos, t = this.line, n = this.col;
+				for (; !this._eof() && this._ch() !== "\n";) this._advance();
+				this.comments.push({
+					kind: "line",
+					marker: "#",
+					text: this.input.slice(e, this.pos),
+					start: e,
+					end: this.pos,
+					line: t,
+					col: n
+				});
+				continue;
+			}
+			if (e === "/") {
+				let e = this.input[this.pos + 1] ?? "";
+				if (e === "/") {
+					let e = this.pos, t = this.line, n = this.col;
+					for (this._advance(), this._advance(); !this._eof() && this._ch() !== "\n";) this._advance();
+					this.comments.push({
+						kind: "line",
+						marker: "//",
+						text: this.input.slice(e, this.pos),
+						start: e,
+						end: this.pos,
+						line: t,
+						col: n
+					});
+					continue;
+				}
+				if (e === "*") {
+					let e = this.pos, t = this.line, n = this.col;
+					this._advance(), this._advance(), this._skipBlockCommentStar(), this.comments.push({
+						kind: "block",
+						marker: "/*",
+						text: this.input.slice(e, this.pos),
+						start: e,
+						end: this.pos,
+						line: t,
+						col: n
+					});
+					continue;
+				}
+				let t = this.pos, n = this.line, r = this.col;
+				this._advance(), this._skipBlockCommentSlash(), this.comments.push({
+					kind: "block",
+					marker: "/",
+					text: this.input.slice(t, this.pos),
+					start: t,
+					end: this.pos,
+					line: n,
+					col: r
+				});
+				continue;
+			}
+			return;
+		}
+	}
+	_skipByteStringComment(e) {
+		let t = this._ch();
+		if (t === "/") {
+			let t = this.input[this.pos + 1] ?? "";
+			if (t === "/") {
+				for (this._advance(), this._advance(); !this._eof() && this._ch() !== "\n";) {
+					if (this._ch() === "\\") {
+						this._advance(), !this._eof() && this._ch() !== "\n" && this._advance();
+						continue;
+					}
+					if (this._ch() === e) break;
+					this._advance();
+				}
+				return !0;
+			}
+			return t === "*" ? (this._advance(), this._advance(), this._skipBlockCommentStar(), !0) : (this._advance(), this._skipBlockCommentSlash(), !0);
+		}
+		if (t === "#") {
+			for (; !this._eof() && this._ch() !== "\n";) {
+				if (this._ch() === "\\") {
+					this._advance(), !this._eof() && this._ch() !== "\n" && this._advance();
+					continue;
+				}
+				if (this._ch() === e) break;
+				this._advance();
+			}
+			return !0;
+		}
+		return !1;
+	}
+	_skipRawComment(e, t, n, r, i) {
+		let a = e[t];
+		if (a === "/") {
+			if (t++, e[t] === "/") {
+				for (t++; t < e.length && e[t] !== "\n";) t++;
+				return t;
+			}
+			if (e[t] === "*") {
+				for (t++; t < e.length;) {
+					if (e[t] === "*" && e[t + 1] === "/") return t + 2;
+					t++;
+				}
+				return t;
+			}
+			for (; t < e.length && e[t] !== "/";) t++;
+			if (t >= e.length) throw SyntaxError(`EDN parse error at line ${r}, column ${i}: unterminated block comment in ${n}`);
+			return t + 1;
+		}
+		if (a === "#") {
+			for (; t < e.length && e[t] !== "\n";) t++;
+			return t;
+		}
+		return -1;
+	}
+	_skipBlockCommentSlash() {
+		let e = this.line, t = this.col;
+		for (; !this._eof();) {
+			if (this._ch() === "\\") {
+				this._advance(), this._eof() || this._advance();
+				continue;
+			}
+			if (this._ch() === "/") break;
+			this._advance();
+		}
+		this._eof() && this._fail("unterminated block comment", e, t), this._advance();
+	}
+	_skipBlockCommentStar() {
+		let e = this.line, t = this.col;
+		for (; !this._eof();) {
+			if (this._ch() === "*" && (this.input[this.pos + 1] ?? "") === "/") {
+				this._advance(), this._advance();
+				return;
+			}
+			this._advance();
+		}
+		this._fail("unterminated block comment", e, t);
+	}
+	_readStringContent(e) {
+		this._advance();
+		let t = "";
+		for (; !this._eof() && this._ch() !== e;) {
+			let n = this._ch();
+			if (n === "\r") {
+				this._advance();
+				continue;
+			}
+			let r = n.codePointAt(0);
+			if ((r < 32 && r !== 10 || r === 127) && this._fail(`unescaped control character U+${r.toString(16).padStart(4, "0")} is not allowed in string literals`), n === "\\") {
+				this._advance();
+				let n = this.line, r = this.col, i = this._advance();
+				switch (i) {
+					case "n":
+						t += "\n";
+						break;
+					case "r":
+						t += "\r";
+						break;
+					case "t":
+						t += "	";
+						break;
+					case "b":
+						t += "\b";
+						break;
+					case "f":
+						t += "\f";
+						break;
+					case "\\":
+						t += "\\";
+						break;
+					case "u":
+						t += this._readUnicodeEscape(e);
+						break;
+					default:
+						if (i === e) {
+							t += i;
+							break;
+						}
+						if (i === "/") {
+							t += "/";
+							break;
+						}
+						this._fail(`invalid escape sequence \\${i} in ${e === "\"" ? "double" : "single"}-quoted string`, n, r);
+				}
+			} else t += this._advance();
+		}
+		return this._eof() && this._fail("unterminated string literal"), this._advance(), t;
+	}
+	_readUnicodeEscape(e) {
+		let t = this.line, n = this.col, r = (r) => {
+			e === "'" && r >= 32 && r <= 126 && r !== 92 && r !== 39 && this._fail(`\\u escape for printable ASCII U+${r.toString(16).padStart(4, "0")} is not allowed in single-quoted strings; write the character literally`, t, n);
+		};
+		if (!this._eof() && this._ch() === "{") {
+			this._advance();
+			let e = "";
+			for (; !this._eof() && this._ch() !== "}";) {
+				let r = this._ch();
+				/[0-9a-fA-F]/.test(r) || this._fail(`invalid character in \\u{} escape: ${JSON.stringify(r)}`, t, n), e += this._advance();
+			}
+			this._eof() && this._fail("unterminated \\u{} escape", t, n), this._advance(), e.length === 0 && this._fail("empty \\u{} escape", t, n);
+			let i = parseInt(e, 16);
+			return i > 1114111 && this._fail(`\\u{${e}} exceeds maximum Unicode code point U+10FFFF`, t, n), i >= 55296 && i <= 57343 && this._fail(`\\u{${e}} is a surrogate code point, which is not a valid Unicode scalar value`, t, n), r(i), String.fromCodePoint(i);
+		}
+		let i = "";
+		for (let e = 0; e < 4; e++) {
+			this._eof() && this._fail("truncated \\uXXXX escape", t, n);
+			let e = this._ch();
+			/[0-9a-fA-F]/.test(e) || this._fail(`invalid hex digit in \\uXXXX escape: ${JSON.stringify(e)}`, t, n), i += this._advance();
+		}
+		let a = parseInt(i, 16);
+		if (a >= 55296 && a <= 56319) {
+			(this._ch() !== "\\" || (this.input[this.pos + 1] ?? "") !== "u") && this._fail(`lone high surrogate \\u${i} must be followed by \\uDC00–\\uDFFF`, t, n), this._advance(), this._advance();
+			let e = this.line, r = this.col, o = "";
+			for (let t = 0; t < 4; t++) this._eof() && this._fail("truncated low-surrogate escape", e, r), o += this._advance();
+			let s = parseInt(o, 16);
+			return (s < 56320 || s > 57343) && this._fail(`\\u${i} (high surrogate) not followed by a valid low surrogate (got \\u${o})`, t, n), String.fromCodePoint(65536 + (a - 55296) * 1024 + (s - 56320));
+		}
+		return a >= 56320 && a <= 57343 && this._fail(`lone low surrogate \\u${i} is not valid`, t, n), r(a), String.fromCharCode(a);
+	}
+	_readRawStringContent() {
+		let e = this.line, t = this.col, n = 0;
+		for (; !this._eof() && this._ch() === "`";) this._advance(), n++;
+		!this._eof() && this._ch() === "\r" && this._advance(), !this._eof() && this._ch() === "\n" && this._advance();
+		let r = "";
+		for (; !this._eof();) {
+			let i = this._ch();
+			if (i === "\r") {
+				this._advance();
+				continue;
+			}
+			if (i === "`") {
+				let i = 0;
+				for (; !this._eof() && this._ch() === "`";) this._advance(), i++;
+				if (i >= n) return r += "`".repeat(i - n), r === "" && this._fail("raw string must not be empty (§2.5.3)", e, t), r;
+				r += "`".repeat(i);
+			} else {
+				let e = i.codePointAt(0);
+				e < 32 && e !== 10 && e !== 13 && this._fail(`raw string content must not contain control character U+${e.toString(16).toUpperCase().padStart(4, "0")} (§2.5.3)`, this.line, this.col), e === 127 && this._fail("raw string content must not contain DEL (U+007F) (§2.5.3)", this.line, this.col), r += this._advance();
+			}
+		}
+		this._fail("unterminated raw string literal", e, t);
+	}
+	_processRawHexContent(e, t, n) {
+		let r = "", i = !1, a = 0;
+		for (; a < e.length;) {
+			let o = e[a];
+			if (o === "\n" || o === " " || o === "\r") {
+				a++;
+				continue;
+			}
+			if (o === "	") throw SyntaxError(`EDN parse error at line ${t}, column ${n}: horizontal tab (HT) is not allowed inside h\`\` raw byte string literals (§5.3.3)`);
+			let s = this._skipRawComment(e, a, "h`` raw byte string", t, n);
+			if (s !== -1) {
+				a = s;
+				continue;
+			}
+			if (o === "." && e[a + 1] === "." && e[a + 2] === ".") {
+				for (a += 3; a < e.length && e[a] === ".";) a++;
+				r += "...", i = !0;
+				continue;
+			}
+			if (/[0-9a-fA-F]/.test(o)) {
+				r += o, a++;
+				continue;
+			}
+			throw SyntaxError(`EDN parse error at line ${t}, column ${n}: unexpected character ${JSON.stringify(o)} in h\`\` raw byte string`);
+		}
+		return {
+			value: r,
+			elided: i
+		};
+	}
+	_processRawB64Content(e, t, n) {
+		let r = "", i = 0;
+		for (; i < e.length;) {
+			let a = e[i];
+			if (a === "\n" || a === " " || a === "\r") {
+				i++;
+				continue;
+			}
+			if (a === "	") throw SyntaxError(`EDN parse error at line ${t}, column ${n}: horizontal tab (HT) is not allowed inside b64\`\` raw byte string literals (§5.3.4)`);
+			if (a === "#") {
+				for (; i < e.length && e[i] !== "\n";) i++;
+				continue;
+			}
+			r += a, i++;
+		}
+		return r;
+	}
+	_processRawB32Content(e, t, n) {
+		let r = "", i = 0;
+		for (; i < e.length;) {
+			let a = e[i];
+			if (a === "\n" || a === " " || a === "\r") {
+				i++;
+				continue;
+			}
+			if (a === "	") throw SyntaxError(`EDN parse error at line ${t}, column ${n}: horizontal tab (HT) is not allowed inside b32\`\`/h32\`\` raw byte string literals (§5.2)`);
+			let o = this._skipRawComment(e, i, "b32``/h32`` raw byte string", t, n);
+			if (o !== -1) {
+				i = o;
+				continue;
+			}
+			r += a, i++;
+		}
+		return r;
+	}
+	_readByteContent(e) {
+		this._advance();
+		let t = "";
+		for (; !this._eof() && this._ch() !== e;) {
+			let n = this._ch();
+			if (n === "\n" || n === " ") {
+				this._advance();
+				continue;
+			}
+			if (n === "\r") {
+				this._advance();
+				continue;
+			}
+			if (n === "	" && this._fail("horizontal tab (HT) is not allowed inside byte string literals (§5.2.2)", this.line, this.col), n === "#") {
+				for (; !this._eof() && this._ch() !== "\n";) {
+					if (this._ch() === "\\") {
+						this._advance(), !this._eof() && this._ch() !== "\n" && this._advance();
+						continue;
+					}
+					if (this._ch() === e) break;
+					this._advance();
+				}
+				continue;
+			}
+			t += this._advance();
+		}
+		return this._eof() && this._fail("unterminated byte string literal"), this._advance(), t;
+	}
+	_readB32Content(e) {
+		this._advance();
+		let t = "";
+		for (; !this._eof() && this._ch() !== e;) {
+			let n = this._ch();
+			if (n === "\n" || n === " " || n === "\r") {
+				this._advance();
+				continue;
+			}
+			n === "	" && this._fail("horizontal tab (HT) is not allowed inside byte string literals (§5.2)", this.line, this.col), !this._skipByteStringComment(e) && (t += this._advance());
+		}
+		return this._eof() && this._fail("unterminated byte string literal"), this._advance(), t;
+	}
+	_readHexByteContentElisionAware(e) {
+		this._advance();
+		let t = "", n = !1;
+		for (; !this._eof() && this._ch() !== e;) {
+			let r = this._ch();
+			if (r === "\n" || r === " " || r === "\r") {
+				this._advance();
+				continue;
+			}
+			if (r === "	" && this._fail("horizontal tab (HT) is not allowed inside hex byte string literals (§5.2.1)", this.line, this.col), !this._skipByteStringComment(e)) {
+				if (r === "." && (this.input[this.pos + 1] ?? "") === "." && (this.input[this.pos + 2] ?? "") === ".") {
+					for (this._advance(), this._advance(), this._advance(); !this._eof() && this._ch() === ".";) this._advance();
+					t.endsWith("...") || (t += "..."), n = !0;
+					continue;
+				}
+				if (/[0-9a-fA-F]/.test(r)) {
+					t += this._advance();
+					continue;
+				}
+				this._fail(`unexpected character ${JSON.stringify(r)} in hex byte string`);
+			}
+		}
+		return this._eof() && this._fail("unterminated hex byte string literal"), this._advance(), {
+			value: t,
+			elided: n
+		};
+	}
+	_readNext() {
+		this._skipWS();
+		let e = this.pos;
+		return {
+			...this._readNextCore(),
+			raw: this.input.slice(e, this.pos),
+			offset: e,
+			endOffset: this.pos
+		};
+	}
+	_readNextCore() {
+		let e = this.line, t = this.col;
+		if (this._eof()) return {
+			type: "EOF",
+			value: "",
+			line: e,
+			col: t
+		};
+		let n = this._ch();
+		switch (n) {
+			case "[": return this._advance(), {
+				type: "LBRACKET",
+				value: "[",
+				line: e,
+				col: t
+			};
+			case "]": return this._advance(), {
+				type: "RBRACKET",
+				value: "]",
+				line: e,
+				col: t
+			};
+			case "{": return this._advance(), {
+				type: "LBRACE",
+				value: "{",
+				line: e,
+				col: t
+			};
+			case "}": return this._advance(), {
+				type: "RBRACE",
+				value: "}",
+				line: e,
+				col: t
+			};
+			case "(": return this._advance(), {
+				type: "LPAREN",
+				value: "(",
+				line: e,
+				col: t
+			};
+			case ")": return this._advance(), {
+				type: "RPAREN",
+				value: ")",
+				line: e,
+				col: t
+			};
+			case ":": return this._advance(), {
+				type: "COLON",
+				value: ":",
+				line: e,
+				col: t
+			};
+			case ",": return this._advance(), {
+				type: "COMMA",
+				value: ",",
+				line: e,
+				col: t
+			};
+			case "<":
+				if ((this.input[this.pos + 1] ?? "") === "<") return this._advance(), this._advance(), {
+					type: "LT_LT",
+					value: "<<",
+					line: e,
+					col: t
+				};
+				this._fail("unexpected character '<'", e, t);
+			case ">":
+				if ((this.input[this.pos + 1] ?? "") === ">") return this._advance(), this._advance(), {
+					type: "GT_GT",
+					value: ">>",
+					line: e,
+					col: t
+				};
+				this._fail("unexpected character '>'", e, t);
+			case "+": {
+				let n = this.input.slice(this.pos + 1);
+				if (n.startsWith("Infinity")) {
+					let r = n[8] ?? "", i = r === "_" && /[0-3i]/.test(n[9] ?? "") && !/[a-zA-Z0-9_]/.test(n[10] ?? "");
+					if (!/[a-zA-Z0-9_]/.test(r) || i) {
+						this._advance();
+						for (let e = 0; e < 8; e++) this._advance();
+						let n = "Infinity";
+						return i && (n += this._advance() + this._advance()), {
+							type: "FLOAT",
+							value: n,
+							line: e,
+							col: t
+						};
+					}
+				}
+				let r = n[0] ?? "";
+				return r >= "0" && r <= "9" || r === "." ? (this._advance(), this._readNumber(e, t)) : (this._advance(), {
+					type: "PLUS",
+					value: "+",
+					line: e,
+					col: t
+				});
+			}
+			case "`": return {
+				type: "RAWSTRING",
+				value: this._readRawStringContent(),
+				line: e,
+				col: t
+			};
+			case "\"": {
+				let n = this._readStringContent("\"");
+				return n === "" && this._ch() === "_" ? (this._advance(), {
+					type: "EMPTY_INDEF_TEXT",
+					value: "",
+					line: e,
+					col: t
+				}) : {
+					type: "TSTR",
+					value: n,
+					line: e,
+					col: t
+				};
+			}
+			case "'": {
+				if ((this.input[this.pos + 1] ?? "") === "'" && (this.input[this.pos + 2] ?? "") === "_") return this._advance(), this._advance(), this._advance(), {
+					type: "EMPTY_INDEF_BYTES",
+					value: "",
+					line: e,
+					col: t
+				};
+				let n = this._readStringContent("'"), r = new TextEncoder().encode(n);
+				return {
+					type: "SQSTR",
+					value: Array.from(r, (e) => e.toString(16).padStart(2, "0")).join(""),
+					line: e,
+					col: t
+				};
+			}
+		}
+		if (n === "-") {
+			let n = this.input.slice(this.pos + 1);
+			if (n.startsWith("Infinity")) {
+				let r = n[8] ?? "", i = r === "_" && /[0-3i]/.test(n[9] ?? "") && !/[a-zA-Z0-9_]/.test(n[10] ?? "");
+				if (!/[a-zA-Z0-9_]/.test(r) || i) {
+					this._advance();
+					for (let e = 0; e < 8; e++) this._advance();
+					let n = "-Infinity";
+					return i && (n += this._advance() + this._advance()), {
+						type: "FLOAT",
+						value: n,
+						line: e,
+						col: t
+					};
+				}
+			}
+			return this._readNumber(e, t);
+		}
+		if (n === "+") {
+			let n = this.input.slice(this.pos + 1);
+			if (n.startsWith("Infinity")) {
+				let r = n[8] ?? "", i = r === "_" && /[0-3i]/.test(n[9] ?? "") && !/[a-zA-Z0-9_]/.test(n[10] ?? "");
+				if (!/[a-zA-Z0-9_]/.test(r) || i) {
+					this._advance();
+					for (let e = 0; e < 8; e++) this._advance();
+					let n = "Infinity";
+					return i && (n += this._advance() + this._advance()), {
+						type: "FLOAT",
+						value: n,
+						line: e,
+						col: t
+					};
+				}
+			}
+			return this._advance(), this._readNumber(e, t);
+		}
+		if (n >= "0" && n <= "9" || n === "." && /[0-9]/.test(this.input[this.pos + 1] ?? "")) return this._readNumber(e, t);
+		if (/[a-zA-Z_]/.test(n)) return this._readIdent(e, t);
+		if (n === ".") {
+			if ((this.input[this.pos + 1] ?? "") === "." && (this.input[this.pos + 2] ?? "") === ".") {
+				for (this._advance(), this._advance(), this._advance(); !this._eof() && this._ch() === ".";) this._advance();
+				return {
+					type: "ELLIPSIS",
+					value: "...",
+					line: e,
+					col: t
+				};
+			}
+			this._fail("unexpected character '.'", e, t);
+		}
+		this._fail(`unexpected character ${JSON.stringify(n)}`, e, t);
+	}
+	_readNumber(e, t) {
+		let n = "";
+		if (this._ch() === "-" && (n += this._advance()), this._ch() === "0") {
+			let r = this.input[this.pos + 1] ?? "";
+			if (r === "x" || r === "X") {
+				n += this._advance() + this._advance();
+				let r = n.length;
+				for (; !this._eof() && /[0-9a-fA-F]/.test(this._ch());) n += this._advance();
+				let i = n.length > r, a = !1, o = !1;
+				if (!this._eof() && this._ch() === ".") {
+					a = !0, n += this._advance();
+					let e = n.length;
+					for (; !this._eof() && /[0-9a-fA-F]/.test(this._ch());) n += this._advance();
+					o = n.length > e;
+				}
+				if (!this._eof() && (this._ch() === "p" || this._ch() === "P")) {
+					a = !0, !i && !o && this._fail(`hex float has no mantissa digits: ${n}`, e, t), n += this._advance(), !this._eof() && (this._ch() === "+" || this._ch() === "-") && (n += this._advance());
+					let r = n.length;
+					for (; !this._eof() && this._ch() >= "0" && this._ch() <= "9";) n += this._advance();
+					n.length === r && this._fail(`hex float missing exponent digits: ${n}`, e, t);
+				} else a && this._fail(`hex float missing 'p' exponent: ${n}`, e, t);
+				if (a) {
+					if (this._ch() === "_") {
+						let e = this.input[this.pos + 1] ?? "", t = this.input[this.pos + 2] ?? "";
+						(e === "0" || e === "1" || e === "2" || e === "3" || e === "i") && !/[0-9a-zA-Z_]/.test(t) && (n += this._advance() + this._advance());
+					}
+					return {
+						type: "FLOAT",
+						value: n,
+						line: e,
+						col: t
+					};
+				}
+				return {
+					type: "INTEGER",
+					value: n,
+					line: e,
+					col: t
+				};
+			}
+			if (r === "o" || r === "O") {
+				for (n += this._advance() + this._advance(); !this._eof() && this._ch() >= "0" && this._ch() <= "7";) n += this._advance();
+				return {
+					type: "INTEGER",
+					value: n,
+					line: e,
+					col: t
+				};
+			}
+			if (r === "b" || r === "B") {
+				for (n += this._advance() + this._advance(); !this._eof() && (this._ch() === "0" || this._ch() === "1");) n += this._advance();
+				return {
+					type: "INTEGER",
+					value: n,
+					line: e,
+					col: t
+				};
+			}
+		}
+		for (; !this._eof() && this._ch() >= "0" && this._ch() <= "9";) n += this._advance();
+		let r = !1;
+		if (!this._eof() && this._ch() === ".") for (r = !0, n += this._advance(); !this._eof() && this._ch() >= "0" && this._ch() <= "9";) n += this._advance();
+		if (!this._eof() && (this._ch() === "e" || this._ch() === "E")) {
+			r = !0, n += this._advance(), !this._eof() && (this._ch() === "+" || this._ch() === "-") && (n += this._advance());
+			let i = n.length;
+			for (; !this._eof() && this._ch() >= "0" && this._ch() <= "9";) n += this._advance();
+			n.length === i && this._fail(`float exponent has no digits: ${JSON.stringify(n)}`, e, t);
+		}
+		if (this._ch() === "_") {
+			let e = this.input[this.pos + 1] ?? "", t = this.input[this.pos + 2] ?? "";
+			(e === "0" || e === "1" || e === "2" || e === "3" || e === "i") && !/[0-9a-zA-Z_]/.test(t) && (n += this._advance() + this._advance());
+		}
+		return {
+			type: r ? "FLOAT" : "INTEGER",
+			value: n,
+			line: e,
+			col: t
+		};
+	}
+	_readIdent(e, t) {
+		let n = "";
+		for (; !this._eof() && /[a-zA-Z0-9_]/.test(this._ch());) n += this._advance();
+		switch (n) {
+			case "true": return {
+				type: "TRUE",
+				value: n,
+				line: e,
+				col: t
+			};
+			case "false": return {
+				type: "FALSE",
+				value: n,
+				line: e,
+				col: t
+			};
+			case "null": return {
+				type: "NULL",
+				value: n,
+				line: e,
+				col: t
+			};
+			case "undefined": return {
+				type: "UNDEFINED",
+				value: n,
+				line: e,
+				col: t
+			};
+			case "NaN":
+			case "NaN_0":
+			case "NaN_1":
+			case "NaN_2":
+			case "NaN_3":
+			case "NaN_i":
+			case "Infinity":
+			case "Infinity_0":
+			case "Infinity_1":
+			case "Infinity_2":
+			case "Infinity_3":
+			case "Infinity_i": return {
+				type: "FLOAT",
+				value: n,
+				line: e,
+				col: t
+			};
+			case "simple": return {
+				type: "SIMPLE",
+				value: n,
+				line: e,
+				col: t
+			};
+			case "_": return {
+				type: "UNDERSCORE",
+				value: "_",
+				line: e,
+				col: t
+			};
+			case "_0": return {
+				type: "ENCODING_INDICATOR",
+				value: "0",
+				line: e,
+				col: t
+			};
+			case "_1": return {
+				type: "ENCODING_INDICATOR",
+				value: "1",
+				line: e,
+				col: t
+			};
+			case "_2": return {
+				type: "ENCODING_INDICATOR",
+				value: "2",
+				line: e,
+				col: t
+			};
+			case "_3": return {
+				type: "ENCODING_INDICATOR",
+				value: "3",
+				line: e,
+				col: t
+			};
+			case "_i": return {
+				type: "ENCODING_INDICATOR",
+				value: "i",
+				line: e,
+				col: t
+			};
+		}
+		let r = n[0] ?? "", i = r >= "a" && r <= "z";
+		if (i || r >= "A" && r <= "Z") {
+			let r = n.slice(1);
+			if (i ? /^[a-z0-9]*$/.test(r) : /^[A-Z0-9]*$/.test(r)) {
+				for (; !this._eof();) {
+					let e = this._ch();
+					if (!(i ? e >= "a" && e <= "z" || e >= "0" && e <= "9" || e === "-" : e >= "A" && e <= "Z" || e >= "0" && e <= "9" || e === "-")) break;
+					n += this._advance();
+				}
+				let r = this._ch();
+				if (r === "\"" && this._fail(`"${n}" prefix requires single quotes or backticks, not double quotes`, e, t), r === "'") switch (n) {
+					case "h": {
+						let { value: n, elided: i } = this._readHexByteContentElisionAware(r);
+						return {
+							type: i ? "BYTES_HEX_ELIDED" : "BYTES_HEX",
+							value: n,
+							line: e,
+							col: t
+						};
+					}
+					case "b64": return {
+						type: "BYTES_B64",
+						value: this._readByteContent(r),
+						line: e,
+						col: t
+					};
+					case "b32": return {
+						type: "BYTES_B32",
+						value: this._readB32Content(r),
+						line: e,
+						col: t
+					};
+					case "h32": return {
+						type: "BYTES_H32",
+						value: this._readB32Content(r),
+						line: e,
+						col: t
+					};
+					default: return {
+						type: "APP_STRING",
+						appPrefix: n,
+						value: this._readStringContent(r),
+						line: e,
+						col: t
+					};
+				}
+				if (r === "`") {
+					let r = this._readRawStringContent();
+					switch (n) {
+						case "h": {
+							let { value: n, elided: i } = this._processRawHexContent(r, e, t);
+							return {
+								type: i ? "BYTES_HEX_ELIDED" : "BYTES_HEX",
+								value: n,
+								line: e,
+								col: t
+							};
+						}
+						case "b64": return {
+							type: "BYTES_B64",
+							value: this._processRawB64Content(r, e, t),
+							line: e,
+							col: t
+						};
+						case "b32": return {
+							type: "BYTES_B32",
+							value: this._processRawB32Content(r, e, t),
+							line: e,
+							col: t
+						};
+						case "h32": return {
+							type: "BYTES_H32",
+							value: this._processRawB32Content(r, e, t),
+							line: e,
+							col: t
+						};
+						default: return {
+							type: "APP_STRING",
+							appPrefix: n,
+							value: r,
+							line: e,
+							col: t
+						};
+					}
+				}
+				if (r === "<" && (this.input[this.pos + 1] ?? "") === "<") return this._advance(), this._advance(), {
+					type: "APP_SEQUENCE",
+					appPrefix: n,
+					value: "",
+					line: e,
+					col: t
+				};
+			}
+		}
+		this._fail(`unknown identifier ${JSON.stringify(n)}`, e, t);
+	}
+}, w = class extends d {
+	indefiniteLength = !1;
+	value;
+	ednEncoding;
+	encodingWidth;
+	ednSource;
+	constructor(e, t) {
+		super(), this.value = e, this.ednEncoding = t?.ednEncoding ?? "hex", this.encodingWidth = t?.encodingWidth, this.ednSource = t?.ednSource;
+	}
+	_toCBOR(e) {
+		return h([m(2, BigInt(this.value.length), this.encodingWidth), this.value]);
+	}
+	_toEDN(e, t) {
+		let n = this.encodingWidth === void 0 ? "" : `_${this.encodingWidth}`;
+		if (e?.preserveByteString && this.ednSource !== void 0) return this.ednSource + n;
+		let r = e?.bstrEncoding ?? this.ednEncoding;
+		return ye(this.value, r, e?.sqstr) + n;
+	}
+	_toJS(e) {
+		return this.value;
+	}
+}, T = class extends d {
+	indefiniteLength = !0;
+	chunks;
+	constructor(e) {
+		super(), this.chunks = e;
+	}
+	_toCBOR(e) {
+		let t = [new Uint8Array([95])];
+		for (let n of this.chunks) t.push(n._toCBOR(e));
+		return t.push(new Uint8Array([255])), h(t);
+	}
+	_toEDN(e, t) {
+		return this.chunks.length === 0 ? "''_" : `(_ ${this.chunks.map((t) => t._toEDN(e, 0)).join(", ")})`;
+	}
+	_toHexDump(e, t) {
+		let n = (e) => e.toString(16).toUpperCase().padStart(2, "0"), r = [{
+			depth: e,
+			hex: n(95),
+			comment: "Start indefinite-length byte string"
+		}];
+		for (let n of this.chunks) r.push(...n._toHexDump(e + 1, t));
+		return r.push({
+			depth: e,
+			hex: n(255),
+			comment: "\"break\""
+		}), r;
+	}
+	_toJS(e) {
+		let t = this.chunks.reduce((e, t) => e + t.value.length, 0), n = new Uint8Array(t), r = 0;
+		for (let e of this.chunks) n.set(e.value, r), r += e.value.length;
+		return n;
+	}
+}, E = class extends d {
+	indefiniteLength = !0;
+	chunks;
+	constructor(e) {
+		super(), this.chunks = e;
+	}
+	_toCBOR(e) {
+		let t = [new Uint8Array([127])];
+		for (let n of this.chunks) t.push(n._toCBOR(e));
+		return t.push(new Uint8Array([255])), h(t);
+	}
+	_toEDN(e, t) {
+		return this.chunks.length === 0 ? "\"\"_" : `(_ ${this.chunks.map((t) => t._toEDN(e, 0)).join(", ")})`;
+	}
+	_toHexDump(e, t) {
+		let n = (e) => e.toString(16).toUpperCase().padStart(2, "0"), r = [{
+			depth: e,
+			hex: n(127),
+			comment: "Start indefinite-length text string"
+		}];
+		for (let n of this.chunks) r.push(...n._toHexDump(e + 1, t));
+		return r.push({
+			depth: e,
+			hex: n(255),
+			comment: "\"break\""
+		}), r;
+	}
+	_toJS(e) {
+		return this.chunks.map((e) => e.value).join("");
+	}
+}, D = class extends d {
+	items;
+	indefiniteLength;
+	encodingWidth;
+	constructor(e, t) {
+		super(), this.items = e, this.indefiniteLength = t?.indefiniteLength ?? !1, this.encodingWidth = t?.encodingWidth;
+	}
+	_toCBOR(e) {
+		if (this.indefiniteLength) {
+			let t = [new Uint8Array([159])];
+			for (let n of this.items) t.push(n._toCBOR(e));
+			return t.push(new Uint8Array([255])), h(t);
+		}
+		let t = [m(4, BigInt(this.items.length), this.encodingWidth)];
+		for (let n of this.items) t.push(n._toCBOR(e));
+		return h(t);
+	}
+	_toEDN(e, t) {
+		let n = v(e), r = e?.preserveComments, i = r && (se(this) || this.items.some(b));
+		n === null && i && (n = "  ");
+		let { inlineSep: a, multilineSep: o, trailSep: s } = x(e, n === null), c = !this.indefiniteLength && this.encodingWidth !== void 0 ? `_${this.encodingWidth} ` : "";
+		if (n === null || this.items.length === 0 && !i) {
+			let n = this.items.map((n) => n._toEDN(e, t + 1)).join(a);
+			return this.indefiniteLength ? this.items.length === 0 ? "[_ ]" : `[_ ${n}]` : `[${c}${n}]`;
+		}
+		let l = y(n, t + 1), u = y(n, t), d = this.indefiniteLength ? "[_ " : `[${c}`, f = [];
+		for (let n = 0; n < this.items.length; n++) {
+			let i = this.items[n];
+			r && f.push(...ce(i, l));
+			let a = n < this.items.length - 1 ? o : s;
+			f.push(`${l}${i._toEDN(e, t + 1)}${a}${r ? le(i) : ""}`);
+		}
+		return r && f.push(...ue(this, l)), `${d}\n${f.join("\n")}\n${u}]`;
+	}
+	_toHexDump(e, t) {
+		let n = (e) => e.toString(16).toUpperCase().padStart(2, "0"), r = (e) => Array.from(e, (e) => e.toString(16).toUpperCase().padStart(2, "0")).join(" ");
+		if (this.indefiniteLength) {
+			let r = [{
+				depth: e,
+				hex: n(159),
+				comment: "Start indefinite-length array"
+			}];
+			for (let n of this.items) r.push(...n._toHexDump(e + 1, t));
+			return r.push({
+				depth: e,
+				hex: n(255),
+				comment: "\"break\""
+			}), r;
+		}
+		let i = [{
+			depth: e,
+			hex: r(m(4, BigInt(this.items.length), this.encodingWidth)),
+			comment: `Array of length ${this.items.length}`
+		}];
+		for (let n of this.items) i.push(...n._toHexDump(e + 1, t));
+		return i;
+	}
+	_toJS(e) {
+		let t = e?.reviver;
+		if (!t) return this.items.map((t) => t._toJS(e));
+		let n = e ? {
+			...e,
+			reviver: void 0
+		} : void 0, r = this.items.map((e) => e._toJS(n)), i = 0;
+		for (let n = 0; n < this.items.length; n++) {
+			let a = n - i, o = this.items[n]._toJS(e), s = t.call(r, String(n), o);
+			s === l || e?.undefinedOmits && s === void 0 ? (r.splice(a, 1), i++) : r[a] = s;
+		}
+		return r;
+	}
+}, O = class extends d {
+	entries;
+	indefiniteLength;
+	encodingWidth;
+	constructor(e, t) {
+		super(), this.entries = e, this.indefiniteLength = t?.indefiniteLength ?? !1, this.encodingWidth = t?.encodingWidth;
+	}
+	_toCBOR(e) {
+		if (this.indefiniteLength) {
+			let t = [new Uint8Array([191])];
+			for (let [n, r] of this.entries) t.push(n._toCBOR(e), r._toCBOR(e));
+			return t.push(new Uint8Array([255])), h(t);
+		}
+		let t = [m(5, BigInt(this.entries.length), this.encodingWidth)];
+		for (let [n, r] of this.entries) t.push(n._toCBOR(e), r._toCBOR(e));
+		return h(t);
+	}
+	_toEDN(e, t) {
+		let n = v(e), r = e?.preserveComments, i = r && (se(this) || this.entries.some(([e, t]) => b(e) || b(t)));
+		n === null && i && (n = "  ");
+		let { inlineSep: a, multilineSep: o, trailSep: s, colSep: c } = x(e, n === null), l = !this.indefiniteLength && this.encodingWidth !== void 0 ? `_${this.encodingWidth} ` : "", u = this.indefiniteLength ? "{_ " : `{${l}`;
+		if (n === null || this.entries.length === 0 && !i) {
+			let n = this.entries.map(([n, r]) => `${n._toEDN(e, t + 1)}${c}${r._toEDN(e, t + 1)}`).join(a);
+			return this.indefiniteLength ? this.entries.length === 0 ? "{_ }" : `{_ ${n}}` : `{${l}${n}}`;
+		}
+		let d = y(n, t + 1), f = y(n, t), p = [];
+		for (let n = 0; n < this.entries.length; n++) {
+			let [i, a] = this.entries[n];
+			r && p.push(...ce(i, d));
+			let l = n < this.entries.length - 1 ? o : s, u = r ? Me([
+				...i.comments?.trailing ?? [],
+				...a.comments?.leading ?? [],
+				...a.comments?.trailing ?? []
+			]) : "";
+			p.push(`${d}${i._toEDN(e, t + 1)}${c}${a._toEDN(e, t + 1)}${l}${u}`);
+		}
+		return r && p.push(...ue(this, d)), `${u}\n${p.join("\n")}\n${f}}`;
+	}
+	_toHexDump(e, t) {
+		let n = (e) => e.toString(16).toUpperCase().padStart(2, "0"), r = (e) => Array.from(e, (e) => e.toString(16).toUpperCase().padStart(2, "0")).join(" ");
+		if (this.indefiniteLength) {
+			let r = [{
+				depth: e,
+				hex: n(191),
+				comment: "Start indefinite-length map"
+			}];
+			for (let [n, i] of this.entries) r.push(...n._toHexDump(e + 1, t)), r.push(...i._toHexDump(e + 1, t));
+			return r.push({
+				depth: e,
+				hex: n(255),
+				comment: "\"break\""
+			}), r;
+		}
+		let i = [{
+			depth: e,
+			hex: r(m(5, BigInt(this.entries.length), this.encodingWidth)),
+			comment: `Map of length ${this.entries.length}`
+		}];
+		for (let [n, r] of this.entries) i.push(...n._toHexDump(e + 1, t)), i.push(...r._toHexDump(e + 1, t));
+		return i;
+	}
+	_toJS(e) {
+		let t = e?.reviver, n = () => {
+			let n = $.from(this.entries, ([t, n]) => [t._toJS(e), n._toJS(e)]);
+			if (!t) return n;
+			let r = e?.undefinedOmits;
+			for (let e = 0; e < n.length; e++) {
+				let [i, a] = n[e], o = t.call(n, i, a);
+				o === l || r && o === void 0 ? n.splice(e--, 1) : n[e] = [i, o];
+			}
+			return n;
+		};
+		return e?.mapAs === "entries" ? n() : e?.mapAs === "object" || this.entries.every(([e]) => e instanceof F) ? (() => {
+			let n = e ? {
+				...e,
+				reviver: void 0
+			} : void 0, r = {};
+			for (let [e, t] of this.entries) {
+				let i = e instanceof F ? e.value : e.toEDN(), a = t._toJS(n);
+				i === "__proto__" ? Object.defineProperty(r, i, {
+					value: a,
+					writable: !0,
+					enumerable: !0,
+					configurable: !0
+				}) : r[i] = a;
+			}
+			if (!t) return r;
+			let i = /* @__PURE__ */ new Map();
+			for (let e = 0; e < this.entries.length; e++) {
+				let [t] = this.entries[e];
+				i.set(t instanceof F ? t.value : t.toEDN(), e);
+			}
+			for (let n = 0; n < this.entries.length; n++) {
+				let [a, o] = this.entries[n], s = a instanceof F ? a.value : a.toEDN();
+				if (i.get(s) !== n) continue;
+				let c = o._toJS(e), u = t.call(r, s, c);
+				u === l || e?.undefinedOmits && u === void 0 ? delete r[s] : s === "__proto__" ? Object.defineProperty(r, s, {
+					value: u,
+					writable: !0,
+					enumerable: !0,
+					configurable: !0
+				}) : r[s] = u;
+			}
+			return r;
+		})() : n();
+	}
+};
+function Me(e) {
+	return e.length === 0 ? "" : " " + e.map((e) => e.text.trimEnd()).join(" ");
+}
+//#endregion
+//#region src/ast/CborSimple.ts
+var k = class e extends d {
+	value;
+	constructor(e) {
+		if (super(), !Number.isInteger(e) || e < 0 || e > 255) throw RangeError("CborSimple value must be an integer in 0–255");
+		this.value = e;
+	}
+	static FALSE = new e(20);
+	static TRUE = new e(21);
+	static NULL = new e(22);
+	static UNDEFINED = new e(23);
+	_toCBOR(e) {
+		return this.value <= 23 ? new Uint8Array([224 | this.value]) : new Uint8Array([248, this.value]);
+	}
+	_toEDN(e, t) {
+		switch (this.value) {
+			case 20: return "false";
+			case 21: return "true";
+			case 22: return "null";
+			case 23: return "undefined";
+			default: return `simple(${this.value})`;
+		}
+	}
+	_toJS(e) {
+		switch (this.value) {
+			case 20: return !1;
+			case 21: return !0;
+			case 22: return null;
+			case 23: return;
+			default: return new u(this.value);
+		}
+	}
+}, A = class extends d {
+	items;
+	constructor(e) {
+		super(), this.items = e;
+	}
+	_content(e) {
+		return h(this.items.map((t) => t._toCBOR(e)));
+	}
+	_toCBOR(e) {
+		let t = this._content(e);
+		return h([m(2, BigInt(t.length)), t]);
+	}
+	_toEDN(e, t) {
+		if (this.items.length === 0) return "<<>>";
+		let n = v(e), { inlineSep: r, multilineSep: i, trailSep: a } = x(e, n === null);
+		if (n === null) return `<<${this.items.map((n) => n._toEDN(e, t + 1)).join(r)}>>`;
+		let o = y(n, t + 1), s = y(n, t), c = this.items.map((n) => `${o}${n._toEDN(e, t + 1)}`), l = c.length - 1;
+		return `<<\n${c.map((e, t) => t < l ? `${e}${i}` : `${e}${a}`).join("\n")}\n${s}>>`;
+	}
+	_toHexDump(e, t) {
+		let n = (e) => Array.from(e, (e) => e.toString(16).toUpperCase().padStart(2, "0")).join(" "), r = this._content().length, i = [{
+			depth: e,
+			hex: n(m(2, BigInt(r))),
+			comment: `Embedded CBOR sequence, ${r} byte${r === 1 ? "" : "s"}`
+		}];
+		for (let n of this.items) i.push(...n._toHexDump(e + 1, t));
+		return i;
+	}
+	_toJS(e) {
+		return this._content();
+	}
+}, Ne = 999n, Pe = class extends C {
+	constructor(e, t) {
+		let n = t.length === 1 && t[0] instanceof F ? t[0] : new D(t);
+		super(Ne, new D([new F(e), n]));
+	}
+	_toEDN(e, t) {
+		let n = this.content, r = n.items[0].value, i = n.items[1];
+		return i instanceof F ? `${r}${Ce(i.value)}` : `${r}<<${i.items.map((n) => n._toEDN(e, t)).join(", ")}>>`;
+	}
+}, Fe = 888n, j = class extends C {
+	constructor(e) {
+		e === void 0 ? super(Fe, k.NULL) : super(Fe, new D(e));
+	}
+	_toEDN(e, t) {
+		return this.content instanceof k ? "..." : this.content instanceof D ? this.content.items.map((n) => n._toEDN(e, t)).join(" + ") : super._toEDN(e, t);
+	}
+}, Ie = 2n, Le = 3n, Re = 18446744073709551615n, ze = -(Re + 1n);
+function Be(e) {
+	if (e < 0n) throw RangeError("bigintToBytes requires a non-negative value");
+	if (e === 0n) return new Uint8Array();
+	let t = e.toString(16);
+	t.length % 2 != 0 && (t = "0" + t);
+	let n = new Uint8Array(t.length / 2);
+	for (let e = 0; e < n.length; e++) n[e] = parseInt(t.slice(e * 2, e * 2 + 2), 16);
+	return n;
+}
+function Ve(e) {
+	let t = 0n;
+	for (let n of e) t = t << 8n | BigInt(n);
+	return t;
+}
+var M = class extends C {
+	bigValue;
+	constructor(e) {
+		if (e <= Re) throw RangeError(`CborBigUint value ${e} fits in CborUint; use CborUint instead`);
+		super(Ie, new w(Be(e))), this.bigValue = e;
+	}
+	_toEDN(e, t) {
+		return this.bigValue.toString();
+	}
+	_toJS(e) {
+		return this.bigValue;
+	}
+}, N = class extends C {
+	bigValue;
+	constructor(e) {
+		if (e >= ze) throw RangeError(`CborBigNint value ${e} fits in CborNint; use CborNint instead`);
+		super(Le, new w(Be(-1n - e))), this.bigValue = e;
+	}
+	_toEDN(e, t) {
+		return this.bigValue.toString();
+	}
+	_toJS(e) {
+		return this.bigValue;
+	}
+};
+//#endregion
+//#region src/edn/parser.ts
+function He(e, t) {
+	let n = new je(e, { offset: t?.offset }), r = new et(n, t?.extensions, t?.unresolvedExtension, t?.allowInvalidUtf8, t?.allowTrailing).parse();
+	return t?.preserveComments && Ze(r, n.comments, e), r;
+}
+function Ue(e) {
+	let t = e, n;
+	if (/[_][0-3i]$/.test(e)) {
+		let r = e[e.length - 1];
+		n = r === "i" ? "i" : Number(r), t = e.slice(0, -2);
+	}
+	return {
+		numStr: t,
+		encodingWidth: n
+	};
+}
+function We(e) {
+	return e.startsWith("-") ? -BigInt(e.slice(1)) : BigInt(e);
+}
+function Ge(e) {
+	if (e === "NaN") return {
+		value: NaN,
+		precision: void 0
+	};
+	if (e === "Infinity") return {
+		value: Infinity,
+		precision: void 0
+	};
+	if (e === "-Infinity") return {
+		value: -Infinity,
+		precision: void 0
+	};
+	if (e.endsWith("_i") || e.endsWith("_0")) throw SyntaxError("EDN parse error: _0 and _i encoding indicators are not valid for floating-point values");
+	let t = e, n;
+	return e.endsWith("_1") ? (n = "half", t = e.slice(0, -2)) : e.endsWith("_2") ? (n = "single", t = e.slice(0, -2)) : e.endsWith("_3") && (n = "double", t = e.slice(0, -2)), /^-?0[xX]/.test(t) ? {
+		value: Oe(t),
+		precision: n
+	} : {
+		value: parseFloat(t),
+		precision: n
+	};
+}
+function Ke(e) {
+	if (typeof Uint8Array.fromHex == "function") return Uint8Array.fromHex(e);
+	if (e.length % 2 != 0) throw SyntaxError(`hex string has odd length: ${e.length}`);
+	let t = new Uint8Array(e.length / 2);
+	for (let n = 0; n < e.length; n += 2) t[n / 2] = parseInt(e.slice(n, n + 2), 16);
+	return t;
+}
+var qe = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", Je = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+function Ye(e, t) {
+	let n = e.replace(/=+$/, "").toUpperCase(), r = n.length % 8;
+	if (r === 1 || r === 3 || r === 6) throw SyntaxError(`invalid base32 length: ${n.length} characters`);
+	let i = new Uint8Array(128).fill(255);
+	for (let e = 0; e < t.length; e++) i[t.charCodeAt(e)] = e;
+	let a = new Uint8Array(Math.floor(n.length * 5 / 8)), o = 0, s = 0, c = 0;
+	for (let e of n) {
+		let t = e.charCodeAt(0), n = t < 128 ? i[t] : 255;
+		if (n === 255) throw SyntaxError(`invalid character in byte string: ${JSON.stringify(e)}`);
+		o = o << 5 | n, s += 5, s >= 8 && (s -= 8, a[c++] = o >> s & 255);
+	}
+	if (s > 0 && o & (1 << s) - 1) throw SyntaxError("non-zero trailing bits in base32 input");
+	return a;
+}
+function Xe(e) {
+	if (typeof Uint8Array.fromBase64 == "function") {
+		let t = /[-_]/.test(e) ? "base64url" : "base64";
+		return Uint8Array.fromBase64(e, {
+			alphabet: t,
+			lastChunkHandling: "loose"
+		});
+	}
+	let t = e.replace(/-/g, "+").replace(/_/g, "/"), n = t + "=".repeat((4 - t.length % 4) % 4), r = atob(n), i = new Uint8Array(r.length);
+	for (let e = 0; e < r.length; e++) i[e] = r.charCodeAt(e);
+	return i;
+}
+function Ze(e, t, n) {
+	if (t.length === 0) return;
+	let r = Qe(e), i = $e(n);
+	for (let a of t) {
+		let t = { ...a }, o = [...r].filter((e) => e.end <= a.start).sort((e, t) => t.end - e.end || t.start - e.start)[0], s = o ? n.slice(o.end, a.start) : "";
+		if (o && i(o.end) === a.line && !s.includes(":")) {
+			P(o.node, "trailing", t);
+			continue;
+		}
+		let c = [...r].filter((e) => e.start < a.start && a.end < e.end).sort((e, t) => t.start - e.start || e.end - t.end)[0], l = [...r].filter((e) => e.start >= a.end).sort((e, t) => e.start - t.start || t.end - e.end)[0];
+		if ((!c || l && l.end <= c.end) && l) {
+			P(l.node, "leading", t);
+			continue;
+		}
+		P(c?.node ?? e, "dangling", t);
+	}
+}
+function Qe(e) {
+	let t = [], n = (e) => {
+		if (e.start !== void 0 && e.end !== void 0 && t.push({
+			node: e,
+			start: e.start,
+			end: e.end
+		}), e instanceof D || e instanceof A) {
+			for (let t of e.items) n(t);
+			return;
+		}
+		if (e instanceof O) {
+			for (let [t, r] of e.entries) n(t), n(r);
+			return;
+		}
+		if (e instanceof T || e instanceof E) {
+			for (let t of e.chunks) n(t);
+			return;
+		}
+		e instanceof C && n(e.content);
+	};
+	return n(e), t;
+}
+function P(e, t, n) {
+	e.comments ??= {}, e.comments[t] ??= [], e.comments[t].push(n);
+}
+function $e(e) {
+	let t = [0];
+	for (let n = 0; n < e.length; n++) e[n] === "\n" && t.push(n + 1);
+	return (n) => {
+		let r = Math.max(0, Math.min(e.length, n));
+		r > 0 && r === e.length && r--;
+		let i = 0, a = t.length - 1;
+		for (; i <= a;) {
+			let e = i + a >> 1;
+			t[e] <= r ? i = e + 1 : a = e - 1;
+		}
+		return a + 1;
+	};
+}
+var et = class {
+	t;
+	allowInvalidUtf8;
+	allowTrailing;
+	extByPrefix;
+	extByTag;
+	unresolvedExtension;
+	constructor(e, t, n, r, i) {
+		this.t = e, this.allowInvalidUtf8 = r, this.allowTrailing = i, this.extByPrefix = /* @__PURE__ */ new Map(), this.extByTag = /* @__PURE__ */ new Map(), this.unresolvedExtension = n ?? "cpa999";
+		for (let e of [...Z, ...t ?? []]) {
+			for (let t of e.appStringPrefixes ?? []) this.extByPrefix.set(t, e);
+			for (let t of e.tagNumbers ?? []) this.extByTag.set(t, e);
+		}
+	}
+	parse() {
+		let e = this.parseValue();
+		if (this.allowTrailing) return e;
+		let t = this.t.peek();
+		return t.type !== "EOF" && this._fail(`unexpected token after value: ${JSON.stringify(t.value)}`, t), e;
+	}
+	parseValue() {
+		let e = this.t.peek().offset, t = this._parseValueNode();
+		return t.start = e, t.end = this.t.lastEndOffset, t;
+	}
+	_parseValueNode() {
+		let e = this.t.peek();
+		switch (e.type) {
+			case "INTEGER": return this.parseIntegerOrTag();
+			case "FLOAT": return this.parseFloat();
+			case "TSTR":
+			case "RAWSTRING": return this.parseString();
+			case "BYTES_HEX":
+			case "SQSTR":
+			case "BYTES_B64":
+			case "BYTES_B32":
+			case "BYTES_H32": return this.t.consume(), this._parseBytesConcat(this._decodeBytesToken(e), e.type, e.raw);
+			case "EMPTY_INDEF_BYTES": return this.t.consume(), new T([]);
+			case "EMPTY_INDEF_TEXT": return this.t.consume(), new E([]);
+			case "TRUE": return this.t.consume(), k.TRUE;
+			case "FALSE": return this.t.consume(), k.FALSE;
+			case "NULL": return this.t.consume(), k.NULL;
+			case "UNDEFINED": return this.t.consume(), k.UNDEFINED;
+			case "SIMPLE": return this.parseSimple();
+			case "LBRACKET": return this.parseArray();
+			case "LBRACE": return this.parseMap();
+			case "LPAREN": return this.parseIndefGroup();
+			case "LT_LT": return this.parseEmbeddedCBOR();
+			case "APP_STRING": {
+				this.t.consume();
+				let t = this.extByPrefix.get(e.appPrefix);
+				if (!t?.parseAppString) {
+					if (this.unresolvedExtension === "cpa999") return new Pe(e.appPrefix, [new F(e.value)]);
+					this._fail(`unknown app-string extension: ${JSON.stringify(e.appPrefix)}`, e);
+				}
+				return t.parseAppString(e.appPrefix, e.value);
+			}
+			case "APP_SEQUENCE": {
+				this.t.consume();
+				let t = [];
+				for (; this.t.peek().type !== "GT_GT" && (this.t.peek().type === "EOF" && this._fail(`unterminated ${e.appPrefix}<<...>>`, e), !(t.length > 0 && this.t.peek().type === "COMMA" && (this.t.consume(), this.t.peek().type === "GT_GT")));) t.push(this.parseValue());
+				this.expect("GT_GT");
+				let n = this.extByPrefix.get(e.appPrefix);
+				if (!n) {
+					if (this.unresolvedExtension === "cpa999") return new Pe(e.appPrefix, t);
+					this._fail(`unknown app-string extension: ${JSON.stringify(e.appPrefix)}`, e);
+				}
+				return n.parseAppSequence || this._fail(`app-string extension ${JSON.stringify(e.appPrefix)} does not support <<...>> form`, e), n.parseAppSequence(e.appPrefix, t);
+			}
+			case "ELLIPSIS": {
+				if (this.t.consume(), this.t.peek().type !== "PLUS") return new j();
+				let e = [new j()];
+				for (; this.t.peek().type === "PLUS";) this.t.consume(), e.push(this.parseValue());
+				return new j(e);
+			}
+			case "BYTES_HEX_ELIDED": return this.t.consume(), this._parseHexElidedConcat(e);
+			default: this._fail(`unexpected token: ${JSON.stringify(e.value)}`, e);
+		}
+	}
+	parseIntegerOrTag() {
+		let e = this.t.consume(), { numStr: t, encodingWidth: n } = Ue(e.value), r = n === void 0 ? this.consumeEncodingIndicator() : n, i = We(t);
+		if (i > 18446744073709551615n) return this.t.peek().type === "LPAREN" && this._fail("tag number exceeds maximum uint64", e), new M(i);
+		if (i < -18446744073709551616n) return new N(i);
+		let a = i >= 0n ? new g(i, r === void 0 ? void 0 : { encodingWidth: r }) : new _(i, r === void 0 ? void 0 : { encodingWidth: r });
+		if (this.t.peek().type === "LPAREN") {
+			a instanceof g || this._fail("tag number must be non-negative", e), this.t.consume();
+			let t = this.parseValue();
+			this.expect("RPAREN");
+			let n = a.value, i = this.extByTag.get(n);
+			if (i?.parseTag) {
+				let e = i.parseTag(n, t);
+				if (e !== void 0) return e;
+			}
+			return new C(n, t, r === void 0 ? void 0 : { encodingWidth: r });
+		}
+		return a;
+	}
+	parseFloat() {
+		let { value: e, precision: t } = Ge(this.t.consume().value);
+		return new S(e, t === void 0 ? void 0 : { precision: t });
+	}
+	parseString() {
+		let e = this.t.consume();
+		if (this.t.peek().type !== "PLUS") {
+			let t = this.consumeEncodingIndicator();
+			return new F(e.value, t === void 0 ? void 0 : { encodingWidth: t });
+		}
+		let t = !1, n = [{ text: e.value }];
+		for (; this.t.peek().type === "PLUS";) {
+			this.t.consume();
+			let e = this.t.peek();
+			e.type === "ELLIPSIS" ? (this.t.consume(), n.push({ ellipsis: !0 }), t = !0) : e.type === "TSTR" || e.type === "RAWSTRING" ? (this.t.consume(), n.push({ text: e.value })) : this._isBytesToken(e.type) ? (this.t.consume(), n.push({ text: this._decodeUtf8(this._decodeBytesToken(e), e) })) : this._fail(`expected string or byte string after +, got ${JSON.stringify(e.value)}`, e);
+		}
+		if (!t) {
+			let e = this.consumeEncodingIndicator();
+			return new F(n.map((e) => "text" in e ? e.text : "").join(""), e === void 0 ? void 0 : { encodingWidth: e });
+		}
+		let r = [], i = "";
+		for (let e of n) "ellipsis" in e ? (i !== "" && (r.push(new F(i)), i = ""), r.push(new j())) : i += e.text;
+		return i !== "" && r.push(new F(i)), new j(r);
+	}
+	_isBytesToken(e) {
+		return e === "BYTES_HEX" || e === "SQSTR" || e === "BYTES_B64" || e === "BYTES_B32" || e === "BYTES_H32";
+	}
+	_decodeBytesToken(e) {
+		switch (e.type) {
+			case "BYTES_HEX":
+			case "SQSTR": return Ke(e.value);
+			case "BYTES_B64": return Xe(e.value);
+			case "BYTES_B32": return Ye(e.value, qe);
+			case "BYTES_H32": return Ye(e.value, Je);
+			default: this._fail("expected byte string token", e);
+		}
+	}
+	_decodeUtf8(e, t) {
+		if (this.allowInvalidUtf8) return new TextDecoder("utf-8", { fatal: !1 }).decode(e);
+		try {
+			return new TextDecoder("utf-8", { fatal: !0 }).decode(e);
+		} catch {
+			this._fail("byte string in text concatenation is not valid UTF-8", t);
+		}
+	}
+	_tokenTypeToEdnEncoding(e) {
+		switch (e) {
+			case "BYTES_B64": return "base64";
+			case "BYTES_B32": return "base32";
+			case "BYTES_H32": return "base32hex";
+			default: return "hex";
+		}
+	}
+	_parseBytesConcat(e, t, n) {
+		if (this.t.peek().type !== "PLUS") {
+			let r = this.consumeEncodingIndicator();
+			return new w(e, {
+				ednEncoding: this._tokenTypeToEdnEncoding(t),
+				ednSource: n,
+				...r === void 0 ? {} : { encodingWidth: r }
+			});
+		}
+		let r = !1, i = [{ bytes: e }];
+		for (; this.t.peek().type === "PLUS";) {
+			this.t.consume();
+			let e = this.t.peek();
+			if (e.type === "ELLIPSIS") this.t.consume(), i.push({ ellipsis: !0 }), r = !0;
+			else if (e.type === "BYTES_HEX_ELIDED") {
+				this.t.consume();
+				let t = this._buildBytesElidedItems(e.value);
+				for (let e of t) e instanceof j ? (i.push({ ellipsis: !0 }), r = !0) : e instanceof w && i.push({ bytes: e.value });
+			} else this._isBytesToken(e.type) ? (this.t.consume(), i.push({ bytes: this._decodeBytesToken(e) })) : e.type === "TSTR" || e.type === "RAWSTRING" ? (this.t.consume(), i.push({ bytes: new TextEncoder().encode(e.value) })) : this._fail(`expected byte string after +, got ${JSON.stringify(e.value)}`, e);
+		}
+		if (!r) {
+			let e = this.consumeEncodingIndicator(), t = i.map((e) => "bytes" in e ? e.bytes : new Uint8Array());
+			return new w(this._concatBytes(t), e === void 0 ? void 0 : { encodingWidth: e });
+		}
+		let a = [], o = [], s = () => {
+			o.length > 0 && (a.push(new w(this._concatBytes([...o]))), o.length = 0);
+		};
+		for (let e of i) "ellipsis" in e ? (s(), a.push(new j())) : o.push(e.bytes);
+		return s(), new j(a);
+	}
+	_parseHexElidedConcat(e) {
+		let t = this._buildBytesElidedItems(e.value);
+		for (; this.t.peek().type === "PLUS";) {
+			this.t.consume();
+			let e = this.t.peek();
+			if (e.type === "ELLIPSIS") this.t.consume(), t.push(new j());
+			else if (e.type === "BYTES_HEX_ELIDED") {
+				this.t.consume();
+				let n = this._buildBytesElidedItems(e.value);
+				this._mergeFirstBytesItem(t, n);
+			} else if (this._isBytesToken(e.type)) {
+				this.t.consume();
+				let n = this._decodeBytesToken(e), r = t[t.length - 1];
+				r instanceof w ? t[t.length - 1] = new w(this._concatBytes([r.value, n])) : t.push(new w(n));
+			} else this._fail(`expected byte string after +, got ${JSON.stringify(e.value)}`, e);
+		}
+		return new j(t);
+	}
+	_buildBytesElidedItems(e) {
+		let t = e.split("..."), n = [];
+		for (let e = 0; e < t.length; e++) e > 0 && n.push(new j()), t[e].length > 0 && n.push(new w(Ke(t[e])));
+		return n;
+	}
+	_mergeFirstBytesItem(e, t) {
+		if (t.length === 0) return;
+		let n = e[e.length - 1], r = t[0];
+		n instanceof w && r instanceof w ? (e[e.length - 1] = new w(this._concatBytes([n.value, r.value])), e.push(...t.slice(1))) : e.push(...t);
+	}
+	_concatBytes(e) {
+		let t = e.reduce((e, t) => e + t.byteLength, 0), n = new Uint8Array(t), r = 0;
+		for (let t of e) n.set(t, r), r += t.byteLength;
+		return n;
+	}
+	parseSimple() {
+		this.t.consume(), this.expect("LPAREN");
+		let e = this.t.peek();
+		e.type !== "INTEGER" && this._fail(`expected integer inside simple(), got ${JSON.stringify(e.value)}`, e), this.t.consume();
+		let { numStr: t } = Ue(e.value), n = Number(We(t));
+		return this.expect("RPAREN"), new k(n);
+	}
+	parseEmbeddedCBOR() {
+		this.t.consume();
+		let e = [];
+		for (; this.t.peek().type !== "GT_GT" && !(e.length > 0 && this.t.peek().type === "COMMA" && (this.t.consume(), this.t.peek().type === "GT_GT"));) e.push(this.parseValue());
+		return this.expect("GT_GT"), new A(e);
+	}
+	parseArray() {
+		this.t.consume();
+		let e = !1, t;
+		if (this.t.peek().type === "UNDERSCORE") this.t.consume(), e = !0;
+		else if (this.t.peek().type === "ENCODING_INDICATOR") {
+			let e = this.t.consume().value;
+			t = e === "i" ? "i" : Number(e);
+		}
+		let n = [];
+		for (; this.t.peek().type !== "RBRACKET" && !(n.length > 0 && this.t.peek().type === "COMMA" && (this.t.consume(), this.t.peek().type === "RBRACKET"));) n.push(this.parseValue());
+		return this.expect("RBRACKET"), new D(n, {
+			indefiniteLength: e,
+			encodingWidth: t
+		});
+	}
+	parseMap() {
+		this.t.consume();
+		let e = !1, t;
+		if (this.t.peek().type === "UNDERSCORE") this.t.consume(), e = !0;
+		else if (this.t.peek().type === "ENCODING_INDICATOR") {
+			let e = this.t.consume().value;
+			t = e === "i" ? "i" : Number(e);
+		}
+		let n = [];
+		for (; this.t.peek().type !== "RBRACE" && !(n.length > 0 && this.t.peek().type === "COMMA" && (this.t.consume(), this.t.peek().type === "RBRACE"));) {
+			let e = this.parseValue();
+			this.expect("COLON");
+			let t = this.parseValue();
+			n.push([e, t]);
+		}
+		return this.expect("RBRACE"), new O(n, {
+			indefiniteLength: e,
+			encodingWidth: t
+		});
+	}
+	parseIndefGroup() {
+		this.t.consume();
+		let e = this.t.peek();
+		e.type !== "UNDERSCORE" && this._fail(`expected _ after (, got ${JSON.stringify(e.value)}`, e), this.t.consume();
+		let t = [];
+		for (; this.t.peek().type !== "RPAREN" && !(t.length > 0 && this.t.peek().type === "COMMA" && (this.t.consume(), this.t.peek().type === "RPAREN"));) t.push(this.parseValue());
+		this.expect("RPAREN"), t.length === 0 && this._fail("empty indefinite group (_ ) is ambiguous; use ''_ for bytes or \"\"_ for text");
+		let n = t[0];
+		if (n instanceof w) return new T(t.map((e, t) => {
+			if (e instanceof w) return e;
+			this._fail(`indefinite byte string chunk ${t} must be a byte string, not a text string`);
+		}));
+		if (n instanceof F) return new E(t.map((e, t) => {
+			if (e instanceof F) return e;
+			this._fail(`indefinite text string chunk ${t} must be a text string, not a byte string`);
+		}));
+		this._fail("indefinite group chunks must be byte strings or text strings");
+	}
+	consumeEncodingIndicator() {
+		if (this.t.peek().type === "ENCODING_INDICATOR") {
+			let e = this.t.consume().value;
+			return e === "i" ? "i" : Number(e);
+		}
+	}
+	expect(e) {
+		let t = this.t.consume();
+		return t.type !== e && this._fail(`expected ${e}, got ${t.type} (${JSON.stringify(t.value)})`, t), t;
+	}
+	_fail(e, t) {
+		let n = t ? ` at line ${t.line}, column ${t.col}` : "";
+		throw SyntaxError(`EDN parse error${n}: ${e}`);
+	}
+}, tt = new TextEncoder(), F = class extends d {
+	indefiniteLength = !1;
+	value;
+	encodingWidth;
+	constructor(e, t) {
+		super(), this.value = e, this.encodingWidth = t?.encodingWidth;
+	}
+	_toCBOR(e) {
+		let t = tt.encode(this.value);
+		return h([m(3, BigInt(t.length), this.encodingWidth), t]);
+	}
+	_toEDN(e, t) {
+		let n = this.encodingWidth === void 0 ? "" : `_${this.encodingWidth}`;
+		return nt(this.value, n, e, t);
+	}
+	_toJS(e) {
+		return this.value;
+	}
+};
+function nt(e, t, n, r) {
+	let i = n?.textStringFormat ?? [], a = v(n);
+	if (i.length === 0 || a === null) return we(e) + t;
+	let o = /* @__PURE__ */ new Map(), s = null;
+	if (i.includes("cboredn") && (s = it(e), s !== null)) for (let { point: e, contentDepth: t } of s) o.set(e, t);
+	if (i.includes("newline")) {
+		let t = s === null ? rt(e, 0) : at(e);
+		for (let { point: e, contentDepth: n } of t) o.has(e) || o.set(e, n);
+	}
+	let c = dt(e, o);
+	if (c.length <= 1) return we(e) + t;
+	let l = c.map(({ text: e }, n) => {
+		let r = we(e);
+		return n === c.length - 1 ? r + t : r;
+	}), u = l[0];
+	for (let e = 1; e < l.length; e++) {
+		let t = y(a, r + 1 + c[e].contentDepth);
+		u += ` +\n${t}${l[e]}`;
+	}
+	return u;
+}
+function rt(e, t) {
+	let n = [];
+	for (let r = 0; r < e.length; r++) {
+		let i = e[r];
+		i === "\r" ? e[r + 1] === "\n" ? (n.push({
+			point: r + 2,
+			contentDepth: t
+		}), r++) : n.push({
+			point: r + 1,
+			contentDepth: t
+		}) : i === "\n" && n.push({
+			point: r + 1,
+			contentDepth: t
+		});
+	}
+	return n;
+}
+function it(e) {
+	try {
+		He(e);
+	} catch {
+		return null;
+	}
+	let t = [], n = new je(e), r = 0, i = null, a = !1, o = 0;
+	for (;;) {
+		let s = n.consume();
+		if (s.type === "EOF") break;
+		let c = !1;
+		if (a || (a = !0, s.offset > 0 && lt(n.comments, 0, s.offset) && t.push({
+			point: s.offset,
+			contentDepth: r
+		})), i !== null) {
+			if (i.kind === "opener" && st.has(s.type)) {
+				i.point = s.endOffset, o = s.endOffset;
+				continue;
+			} else i.kind === "opener" && I.has(s.type) && ut(e, i.point, s.offset) ? c = !0 : t.push({
+				point: s.offset,
+				contentDepth: i.contentDepth
+			});
+			i = null;
+		}
+		ct.has(s.type) ? (r++, i = {
+			point: s.endOffset,
+			contentDepth: r,
+			kind: "opener"
+		}) : I.has(s.type) ? (r = Math.max(0, r - 1), c || t.push({
+			point: s.offset,
+			contentDepth: r
+		})) : s.type === "COMMA" && (i = {
+			point: s.endOffset,
+			contentDepth: r,
+			kind: "comma"
+		}), o = s.endOffset;
+	}
+	let s = n.comments.find((e) => e.start >= o);
+	return s !== void 0 && t.push({
+		point: s.start,
+		contentDepth: r
+	}), t;
+}
+function at(e) {
+	let t = [], n = new je(e), r = 0;
+	for (;;) {
+		let i = n.consume();
+		if (i.type === "EOF") break;
+		if (ct.has(i.type)) r++;
+		else if (I.has(i.type)) r = Math.max(0, r - 1);
+		else if (i.type !== "COMMA" && ot.has(i.type)) {
+			let n = e.slice(i.offset, i.endOffset);
+			for (let { point: e } of rt(n, 0)) t.push({
+				point: i.offset + e,
+				contentDepth: r + 1
+			});
+		}
+	}
+	return t;
+}
+var ot = new Set(["TSTR", "RAWSTRING"]), st = new Set(["ENCODING_INDICATOR", "UNDERSCORE"]), ct = new Set([
+	"LBRACKET",
+	"LBRACE",
+	"LPAREN",
+	"LT_LT"
+]), I = new Set([
+	"RBRACKET",
+	"RBRACE",
+	"RPAREN",
+	"GT_GT"
+]);
+function lt(e, t, n) {
+	return e.some((e) => e.start >= t && e.end <= n);
+}
+function ut(e, t, n) {
+	return /^[\t\n\r ]*$/.test(e.slice(t, n));
+}
+function dt(e, t) {
+	let n = [...t].filter(([t]) => t > 0 && t < e.length).sort(([e], [t]) => e - t);
+	if (n.length === 0) return [{
+		text: e,
+		contentDepth: 0
+	}];
+	let r = [], i = 0, a = 0;
+	for (let [t, o] of n) t !== i && (r.push({
+		text: e.slice(i, t),
+		contentDepth: a
+	}), i = t, a = o);
+	return i < e.length && r.push({
+		text: e.slice(i),
+		contentDepth: a
+	}), r;
+}
+//#endregion
+//#region src/extensions/dt.ts
+function L(e) {
+	if (Number.isInteger(e)) return (/* @__PURE__ */ new Date(e * 1e3)).toISOString().replace(/\.000Z$/, "Z");
+	let t = Math.round(e * 1e3);
+	if (t / 1e3 === e) return new Date(t).toISOString().replace(/\.000Z$/, "Z");
+	let n = Math.floor(e), r = e - n, i = (/* @__PURE__ */ new Date(n * 1e3)).toISOString().replace(/\.\d+Z$/, ""), a = r.toString(), o = a.indexOf("."), s = o >= 0 ? a.slice(o + 1) : "0";
+	for (; s.length < 3;) s += "0";
+	return `${i}.${s}Z`;
+}
+function ft(e) {
+	if (e.length !== 1) throw SyntaxError("dt<<...>>: expected exactly one item");
+	let t = e[0];
+	if (t instanceof F) return t.value;
+	if (t instanceof w) return new TextDecoder("utf-8", { fatal: !0 }).decode(t.value);
+	throw SyntaxError("dt<<...>>: expected a text string or byte string");
+}
+function R(e) {
+	let t = e.match(/^(.+T\d{2}:\d{2}:\d{2})(\.\d+)(Z|[+-]\d{2}:\d{2})$/i), n, r;
+	t ? (n = t[1] + t[3], r = parseFloat("0" + t[2])) : (n = e, r = void 0);
+	let i = Date.parse(n);
+	if (isNaN(i)) throw SyntaxError(`dt: invalid RFC 3339 date-time: ${JSON.stringify(e)}`);
+	if (r === void 0) {
+		let e = i / 1e3;
+		return e >= 0 ? new mt(BigInt(e)) : new ht(BigInt(e));
+	}
+	return new gt(i / 1e3 + r);
+}
+var pt = 1n, mt = class extends g {
+	constructor(e, t) {
+		super(e, t);
+	}
+	_toEDN(e, t) {
+		return e?.appStrings === !1 ? super._toEDN(e, t) : `dt'${L(Number(this.value))}'`;
+	}
+}, ht = class extends _ {
+	constructor(e, t) {
+		super(e, t);
+	}
+	_toEDN(e, t) {
+		return e?.appStrings === !1 ? super._toEDN(e, t) : `dt'${L(Number(this.value))}'`;
+	}
+}, gt = class extends S {
+	constructor(e, t) {
+		super(e, t);
+	}
+	_toEDN(e, t) {
+		return e?.appStrings === !1 ? super._toEDN(e, t) : `dt'${L(this.value)}'`;
+	}
+}, _t = class extends C {
+	constructor(e, t) {
+		super(pt, R(e), t);
+	}
+	_toEDN(e, t) {
+		if (e?.appStrings === !1) return super._toEDN(e, t);
+		let n = this.content;
+		return `DT'${L(n instanceof S ? n.value : Number(n.value))}'`;
+	}
+}, vt = class extends _t {
+	constructor(e, t) {
+		super(e, t);
+	}
+	_toJS(e) {
+		let t = this.content, n = t instanceof S ? t.value * 1e3 : Number(t.value) * 1e3;
+		return new Date(n);
+	}
+};
+function yt(e) {
+	let t = e?.jsDate ?? !1;
+	function n(e) {
+		return t ? new vt(e) : new _t(e);
+	}
+	let r = {
+		appStringPrefixes: ["dt", "DT"],
+		tagNumbers: [pt],
+		parseAppString(e, t) {
+			return e === "DT" ? n(t) : R(t);
+		},
+		parseAppSequence(e, t) {
+			let r = ft(t);
+			return e === "DT" ? n(r) : R(r);
+		},
+		parseTag(e, t) {
+			if (e !== 1n) return;
+			let r;
+			if (t instanceof g) r = Number(t.value);
+			else if (t instanceof _) r = Number(t.value);
+			else if (t instanceof S) r = t.value;
+			else return;
+			return n(L(r));
+		}
+	};
+	return t && (r.fromJS = (e, t) => {
+		if (e instanceof Date) return new vt(L(e.getTime() / 1e3));
+	}, r.isJSType = (e) => e instanceof Date), r;
+}
+var bt = yt(), xt = yt({ jsDate: !0 });
+//#endregion
+//#region src/utils/ip.ts
+function St(e) {
+	let t = e.split(".");
+	if (t.length !== 4) throw SyntaxError(`ip: invalid IPv4 address: ${JSON.stringify(e)}`);
+	let n = new Uint8Array(4);
+	for (let e = 0; e < 4; e++) {
+		let r = t[e];
+		if (!/^\d+$/.test(r) || r.length > 1 && r[0] === "0") throw SyntaxError(`ip: invalid IPv4 octet: ${JSON.stringify(r)}`);
+		let i = parseInt(r, 10);
+		if (i > 255) throw SyntaxError(`ip: IPv4 octet out of range: ${i}`);
+		n[e] = i;
+	}
+	return n;
+}
+function Ct(e) {
+	let t = new Uint8Array(16);
+	if (e === "::") return t;
+	let n = e, r = null, i = e.match(/^(.*):(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
+	i && (n = i[1], n.endsWith(":") && (n += ":"), r = St(i[2]));
+	let a = n.split("::");
+	if (a.length > 2) throw SyntaxError(`ip: invalid IPv6 address: ${JSON.stringify(e)}`);
+	let o = a.length === 2, s = a[0] ? a[0].split(":") : [], c = o && a[1] ? a[1].split(":") : [], l = r ? 6 : 8;
+	if (!o && s.length !== l || o && s.length + c.length >= l) throw SyntaxError(`ip: invalid IPv6 address: ${JSON.stringify(e)}`);
+	let u = l - s.length - c.length, d = [
+		...s,
+		...Array(u).fill("0"),
+		...c
+	], f = 0;
+	for (let e of d) {
+		if (!/^[0-9a-fA-F]{1,4}$/.test(e)) throw SyntaxError(`ip: invalid IPv6 group: ${JSON.stringify(e)}`);
+		let n = parseInt(e, 16);
+		t[f++] = n >> 8 & 255, t[f++] = n & 255;
+	}
+	return r && t.set(r, 12), t;
+}
+function wt(e) {
+	return Array.from(e).join(".");
+}
+function Tt(e) {
+	let t = e.slice(0, 10).every((e) => e === 0) && e[10] === 255 && e[11] === 255 ? wt(e.slice(12)) : null, n = t ? 6 : 8, r = [];
+	for (let t = 0; t < n * 2; t += 2) r.push(e[t] << 8 | e[t + 1]);
+	let i = -1, a = 0, o = 0;
+	for (; o < n;) if (r[o] === 0) {
+		let e = o + 1;
+		for (; e < n && r[e] === 0;) e++;
+		e - o > a && (i = o, a = e - o), o = e;
+	} else o++;
+	a < 2 && (i = -1);
+	let s = (e) => e.toString(16), c;
+	return c = i === -1 ? r.map(s).join(":") : `${r.slice(0, i).map(s).join(":")}::${r.slice(i + a).map(s).join(":")}`, t ? `${c}:${t}` : c;
+}
+//#endregion
+//#region src/extensions/ip.ts
+var Et = "ip", z = "IP", B = 52n, V = 54n;
+function Dt(e) {
+	if (e.length !== 1) throw SyntaxError("ip<<...>>: expected exactly one item");
+	let t = e[0];
+	if (t instanceof F) return t.value;
+	if (t instanceof w) return new TextDecoder("utf-8", { fatal: !0 }).decode(t.value);
+	throw SyntaxError("ip<<...>>: expected a text string or byte string");
+}
+function Ot(e) {
+	return /^\d/.test(e) && e.includes(".") && !e.includes(":") ? {
+		bytes: St(e),
+		isV4: !0
+	} : {
+		bytes: Ct(e),
+		isV4: !1
+	};
+}
+function H(e) {
+	if (e.length === 4) return wt(e);
+	if (e.length === 16) return Tt(e);
+	throw SyntaxError(`ip: unexpected byte length: ${e.length}`);
+}
+function kt(e, t) {
+	let n = new Uint8Array(e.length);
+	n.set(e);
+	let r = Math.floor(t / 8), i = t % 8;
+	i > 0 && r < e.length && (n[r] &= 255 << 8 - i & 255);
+	for (let t = r + +(i > 0); t < e.length; t++) n[t] = 0;
+	let a = Math.ceil(t / 8);
+	for (; a > 0 && n[a - 1] === 0;) a--;
+	return n.slice(0, a);
+}
+function At(e, t) {
+	let n = new Uint8Array(t);
+	return n.set(e), n;
+}
+var jt = class extends w {
+	_toEDN(e, t) {
+		return e?.appStrings === !1 ? super._toEDN(e, t) : `${Et}'${H(this.value)}'`;
+	}
+}, Mt = class extends D {
+	_isV4;
+	constructor(e, t, n) {
+		super([new g(BigInt(e)), new w(t)]), this._isV4 = n;
+	}
+	_toEDN(e, t) {
+		if (e?.appStrings === !1) return super._toEDN(e, t);
+		let n = Number(this.items[0].value), r = this.items[1].value;
+		return `${Et}'${H(At(r, this._isV4 ? 4 : 16))}/${n}'`;
+	}
+}, U = class extends C {
+	constructor(e, t) {
+		super(e, t);
+	}
+	_toEDN(e, t) {
+		if (e?.appStrings === !1) return super._toEDN(e, t);
+		let n = this.tag === B ? 4 : 16, r = this.content;
+		if (r instanceof w) return `${z}'${H(r.value)}'`;
+		if (r instanceof D && r.items.length === 2 && r.items[0] instanceof g && r.items[1] instanceof w) {
+			let e = Number(r.items[0].value);
+			return `${z}'${H(At(r.items[1].value, n))}/${e}'`;
+		}
+		return super._toEDN(e, t);
+	}
+};
+function Nt(e, t) {
+	let n = t.indexOf("/");
+	if (n === -1) {
+		let { bytes: n, isV4: r } = Ot(t);
+		return e === z ? new U(r ? B : V, new w(n)) : new jt(n);
+	}
+	let r = t.slice(0, n), i = t.slice(n + 1);
+	if (!/^\d+$/.test(i)) throw SyntaxError(`ip: invalid prefix length: ${JSON.stringify(i)}`);
+	let a = parseInt(i, 10), { bytes: o, isV4: s } = Ot(r), c = s ? 32 : 128;
+	if (a > c) throw SyntaxError(`ip: prefix length ${a} exceeds maximum ${c} for ${s ? "IPv4" : "IPv6"}`);
+	let l = kt(o, a);
+	return e === z ? new U(s ? B : V, new D([new g(BigInt(a)), new w(l)])) : new Mt(a, l, s);
+}
+var Pt = {
+	appStringPrefixes: [Et, z],
+	tagNumbers: [B, V],
+	parseAppString(e, t) {
+		return Nt(e, t);
+	},
+	parseAppSequence(e, t) {
+		return Nt(e, Dt(t));
+	},
+	parseTag(e, t) {
+		if (!(e !== B && e !== V) && (t instanceof w || t instanceof D)) return new U(e, t);
+	}
+}, Ft = 18446744073709551615n, It = -(Ft + 1n), Lt = {
+	tagNumbers: [Ie, Le],
+	parseTag(e, t) {
+		if (t instanceof w) {
+			if (e === 2n) {
+				let e = Ve(t.value);
+				return e > Ft ? new M(e) : void 0;
+			}
+			if (e === 3n) {
+				let e = -1n - Ve(t.value);
+				return e < It ? new N(e) : void 0;
+			}
+		}
+	}
+}, Rt = "cri", zt = "CRI", Bt = 99n, Vt = new Map([
+	["coap", -1n],
+	["coaps", -2n],
+	["http", -3n],
+	["https", -4n],
+	["urn", -5n],
+	["did", -6n],
+	["coap+tcp", -7n],
+	["coaps+tcp", -8n],
+	["coap+ws", -25n],
+	["coaps+ws", -26n]
+]), Ht = new Map([...Vt.entries()].map(([e, t]) => [t, e]));
+function W(e) {
+	try {
+		return decodeURIComponent(e);
+	} catch {
+		return e;
+	}
+}
+function Ut(e) {
+	return Array.from(new TextEncoder().encode(e), (e) => `%${e.toString(16).toUpperCase().padStart(2, "0")}`).join("");
+}
+function G(e, t) {
+	let n = "";
+	for (let r of e) n += t(r) ? r : Ut(r);
+	return n;
+}
+function Wt(e) {
+	return /[A-Za-z0-9\-._~]/.test(e);
+}
+function Gt(e) {
+	return /[!$&'()*+,;=]/.test(e);
+}
+function Kt(e) {
+	return Wt(e) || Gt(e) || e === ":" || e === "@";
+}
+function qt(e) {
+	return (Kt(e) || e === "/" || e === "?") && e !== "&";
+}
+function Jt(e) {
+	return Kt(e) || e === "/" || e === "?";
+}
+function Yt(e) {
+	return Wt(e) || Gt(e) || e === ":";
+}
+function Xt(e) {
+	return Wt(e) || Gt(e);
+}
+function Zt(e) {
+	let t = [], n = e, r = n.indexOf("@");
+	r >= 0 && (t.push(k.FALSE), t.push(new F(W(n.slice(0, r)))), n = n.slice(r + 1));
+	let i, a = null;
+	if (n.startsWith("[")) {
+		let e = n.indexOf("]");
+		if (e < 0) throw SyntaxError("cri: unterminated IPv6 bracket in authority");
+		i = n.slice(1, e);
+		let r = n.slice(e + 1);
+		if (r.startsWith(":")) a = r.slice(1);
+		else if (r.length > 0) throw SyntaxError("cri: unexpected characters after ']' in authority");
+		t.push(new w(Ct(i)));
+	} else {
+		let e = n.lastIndexOf(":");
+		if (e >= 0 ? (i = n.slice(0, e), a = n.slice(e + 1)) : i = n, i !== "") if (/^\d{1,3}(\.\d{1,3}){3}$/.test(i)) t.push(new w(St(i)));
+		else for (let e of i.toLowerCase().split(".")) t.push(new F(e));
+	}
+	if (a !== null && a !== "") {
+		if (!/^\d+$/.test(a)) throw SyntaxError(`cri: invalid port: ${JSON.stringify(a)}`);
+		let e = parseInt(a, 10);
+		if (e > 65535) throw SyntaxError(`cri: port ${e} out of range`);
+		t.push(new g(BigInt(e)));
+	}
+	return new D(t);
+}
+function Qt(e) {
+	let t = e.items, n = 0, r = "";
+	if (n < t.length && t[n] instanceof k && t[n].value === 20) {
+		n++;
+		let e = t[n++];
+		r += G(e.value, Yt) + "@";
+	}
+	if (n >= t.length) return r;
+	let i = t[n];
+	if (i instanceof w) {
+		n++;
+		let { length: e } = i.value;
+		if (e === 4) r += wt(i.value);
+		else if (e === 16) r += "[" + Tt(i.value) + "]";
+		else throw Error(`cri: unexpected host-ip byte length: ${e}`);
+		n < t.length && t[n] instanceof F && (r += `%25${G(t[n++].value, Xt)}`);
+	} else {
+		let e = [];
+		for (; n < t.length && t[n] instanceof F;) e.push(G(t[n++].value, Xt));
+		r += e.join(".");
+	}
+	return n < t.length && t[n] instanceof g && (r += ":" + t[n].value.toString()), r;
+}
+function $t(e) {
+	let t = e.slice(2), n = t.indexOf("/"), r, i;
+	return n >= 0 ? (r = t.slice(0, n), i = t.slice(n + 1).split("/").map((e) => new F(W(e)))) : (r = t, i = []), {
+		authority: Zt(r),
+		pathSegments: i
+	};
+}
+function en(e) {
+	let t = e, n = null, r = t.indexOf("#");
+	r >= 0 && (n = W(t.slice(r + 1)), t = t.slice(0, r));
+	let i = null, a = t.indexOf("?");
+	if (a >= 0) {
+		let e = t.slice(a + 1);
+		t = t.slice(0, a), i = e.split("&").map((e) => new F(W(e)));
+	}
+	let o = [], s = /^([a-zA-Z][a-zA-Z0-9+.\-]*):([\s\S]*)$/.exec(t);
+	if (s) {
+		let e = s[1].toLowerCase(), t = s[2], n = Vt.get(e);
+		if (o.push(n === void 0 ? new F(e) : new _(n)), t.startsWith("//")) {
+			let { authority: e, pathSegments: n } = $t(t);
+			o.push(e, new D(n));
+		} else if (t.startsWith("/")) {
+			let e = t.slice(1).split("/").map((e) => new F(W(e)));
+			o.push(k.NULL, new D(e));
+		} else {
+			let e = t.split("/").map((e) => new F(W(e)));
+			o.push(k.TRUE, new D(e));
+		}
+	} else if (t.startsWith("//")) {
+		let { authority: e, pathSegments: n } = $t(t);
+		o.push(k.FALSE, e, new D(n));
+	} else if (t.startsWith("/")) {
+		let e = t.slice(1).split("/").map((e) => new F(W(e)));
+		o.push(k.TRUE, new D(e));
+	} else if (t === "") o.push(new g(0n));
+	else {
+		let n = 1n, r = t, i = !1;
+		for (r.startsWith("./") && (i = !0, r = r.slice(2)); r.startsWith("../");) n++, r = r.slice(3);
+		if (r === ".." ? (n++, r = "") : r === "." && (r = ""), n === 1n && !i && r !== "" && r.split("/")[0].includes(":")) throw SyntaxError(`cri: invalid relative-path reference — first segment must not contain ':' without a './' prefix (RFC 3986 §3.3): ${JSON.stringify(e)}`);
+		let a = r === "" ? [] : r.split("/").map((e) => new F(W(e)));
+		o.push(new g(n), new D(a));
+	}
+	if (i !== null && o.push(new D(i)), n !== null && (i === null && o.push(k.NULL), o.push(new F(n))), n !== null && i === null && o.splice(o.length - 2, 1), i === null && n === null) {
+		let e = o[o.length - 1];
+		e instanceof D && e.items.length === 0 && o.pop();
+	}
+	return o.length === 1 && o[0] instanceof g && o[0].value === 0n ? [] : o;
+}
+function K(e, t) {
+	let n = t, r = "";
+	if (n < e.length) {
+		let t = e[n];
+		if (t instanceof D) {
+			if (n++, t.items.length > 0) {
+				let e = t.items.map((e) => {
+					if (!(e instanceof F)) throw Error("cri: query item must be a text string");
+					return G(e.value, qt);
+				});
+				r += "?" + e.join("&");
+			}
+		} else t instanceof k && t.value === 22 && n++;
+	}
+	return n < e.length && e[n] instanceof F && (r += "#" + G(e[n].value, Jt)), r;
+}
+function q(e) {
+	return e.items.map((e) => {
+		if (!(e instanceof F)) throw Error("cri: path segment must be a text string");
+		return G(e.value, Kt);
+	});
+}
+function tn(e) {
+	if (e.length === 0) return "";
+	let t = 0, n = e[t++];
+	if (n instanceof _ || n instanceof F) {
+		let r;
+		if (n instanceof _) {
+			let e = Ht.get(n.value);
+			if (e === void 0) throw Error(`cri: unrecognised scheme-id ${n.value}`);
+			r = e + ":";
+		} else r = n.value + ":";
+		if (t >= e.length) return r;
+		let i = e[t++], a = "", o = !1;
+		if (i instanceof D) a = "//" + Qt(i), o = !0;
+		else if (i instanceof k) if (i.value === 22) o = !0;
+		else if (i.value === 21) o = !1;
+		else throw Error(`cri: unexpected no-authority value: simple(${i.value})`);
+		else throw Error("cri: unexpected type for authority element");
+		let s = "";
+		if (t < e.length && e[t] instanceof D) {
+			let n = e[t++];
+			n.items.length > 0 && (s = (o ? "/" : "") + q(n).join("/"));
+		}
+		return r + a + s + K(e, t);
+	}
+	if (n instanceof k && n.value === 20) {
+		if (t >= e.length || !(e[t] instanceof D)) throw Error("cri: network-path reference requires an authority array");
+		let n = Qt(e[t++]), r = "";
+		if (t < e.length && e[t] instanceof D) {
+			let n = e[t++];
+			n.items.length > 0 && (r = "/" + q(n).join("/"));
+		}
+		return "//" + n + r + K(e, t);
+	}
+	if (n instanceof k && n.value === 21) {
+		let n = "/";
+		if (t < e.length && e[t] instanceof D) {
+			let r = e[t++];
+			n = "/" + q(r).join("/");
+		}
+		return n + K(e, t);
+	}
+	if (n instanceof g) {
+		let r = n.value;
+		if (r === 0n) return K(e, t);
+		let i = r === 1n ? "" : "../".repeat(Number(r) - 1), a;
+		if (t < e.length && e[t] instanceof D) {
+			let n = e[t++];
+			if (n.items.length > 0) {
+				let e = q(n);
+				a = (r === 1n && e[0].includes(":") ? "./" : i) + e.join("/");
+			} else a = i === "" ? "./" : i;
+		} else a = i === "" ? "./" : i;
+		return a + K(e, t);
+	}
+	throw Error("cri: unrecognised first element type in CRI array");
+}
+var nn = class extends D {
+	_toEDN(e, t) {
+		if (e?.appStrings === !1) return super._toEDN(e, t);
+		try {
+			return `${Rt}'${tn(this.items)}'`;
+		} catch {
+			return super._toEDN(e, t);
+		}
+	}
+}, rn = class extends C {
+	constructor(e) {
+		super(Bt, e);
+	}
+	_toEDN(e, t) {
+		if (e?.appStrings === !1) return super._toEDN(e, t);
+		try {
+			return `${zt}'${tn(this.content.items)}'`;
+		} catch {
+			return super._toEDN(e, t);
+		}
+	}
+};
+function an(e) {
+	if (e.length !== 1) throw SyntaxError("cri<<...>>: expected exactly one item");
+	let t = e[0];
+	if (t instanceof F) return t.value;
+	if (t instanceof w) return new TextDecoder("utf-8", { fatal: !0 }).decode(t.value);
+	throw SyntaxError("cri<<...>>: expected a text string or byte string");
+}
+function on(e, t) {
+	let n = new nn(en(t));
+	return e === zt ? new rn(n) : n;
+}
+var sn = {
+	appStringPrefixes: [Rt, zt],
+	tagNumbers: [Bt],
+	parseAppString(e, t) {
+		return on(e, t);
+	},
+	parseAppSequence(e, t) {
+		return on(e, an(t));
+	},
+	parseTag(e, t) {
+		if (e === 99n && t instanceof D) return new rn(new nn(t.items, {
+			indefiniteLength: t.indefiniteLength,
+			encodingWidth: t.encodingWidth
+		}));
+	}
+}, cn = new TextDecoder("utf-8", {
+	fatal: !0,
+	ignoreBOM: !0
+});
+function J(e) {
+	throw Error(`CBOR decode error: ${e}`);
+}
+function Y(e, t, n) {
+	if (n <= 23) return {
+		value: BigInt(n),
+		nextOffset: t
+	};
+	switch (n) {
+		case 24: return t + 1 > e.byteLength && J("unexpected end of input"), {
+			value: BigInt(e.getUint8(t)),
+			nextOffset: t + 1
+		};
+		case 25: return t + 2 > e.byteLength && J("unexpected end of input"), {
+			value: BigInt(e.getUint16(t, !1)),
+			nextOffset: t + 2
+		};
+		case 26: return t + 4 > e.byteLength && J("unexpected end of input"), {
+			value: BigInt(e.getUint32(t, !1)),
+			nextOffset: t + 4
+		};
+		case 27: return t + 8 > e.byteLength && J("unexpected end of input"), {
+			value: e.getBigUint64(t, !1),
+			nextOffset: t + 8
+		};
+		default: J(`reserved additional info value: ${n}`);
+	}
+}
+function X(e, t, n) {
+	let r = t, i = ln(e, t, n);
+	return i.value.start = r, i.value.end = i.nextOffset, i;
+}
+function ln(e, t, n) {
+	t >= e.byteLength && J("unexpected end of input");
+	let r = e.getUint8(t++), i = r >> 5, a = r & 31;
+	switch (i) {
+		case 0: {
+			let { value: n, nextOffset: r } = Y(e, t, a);
+			return {
+				value: new g(n),
+				nextOffset: r
+			};
+		}
+		case 1: {
+			let { value: n, nextOffset: r } = Y(e, t, a);
+			return {
+				value: new _(-1n - n),
+				nextOffset: r
+			};
+		}
+		case 2: {
+			if (a === 31) {
+				let r = [], i = t;
+				for (;;) {
+					if (i >= e.byteLength && J("unexpected end of indefinite byte string"), e.getUint8(i) === 255) {
+						i++;
+						break;
+					}
+					let t = X(e, i, n);
+					t.value instanceof w || J("indefinite-length byte string chunk must be a definite byte string"), r.push(t.value), i = t.nextOffset;
+				}
+				return {
+					value: new T(r),
+					nextOffset: i
+				};
+			}
+			let { value: r, nextOffset: i } = Y(e, t, a), o = Number(r);
+			return i + o > e.byteLength && J("byte string extends beyond input"), {
+				value: new w(new Uint8Array(e.buffer, e.byteOffset + i, o).slice()),
+				nextOffset: i + o
+			};
+		}
+		case 3: {
+			if (a === 31) {
+				let r = [], i = t;
+				for (;;) {
+					if (i >= e.byteLength && J("unexpected end of indefinite text string"), e.getUint8(i) === 255) {
+						i++;
+						break;
+					}
+					let t = X(e, i, n);
+					t.value instanceof F || J("indefinite-length text string chunk must be a definite text string"), r.push(t.value), i = t.nextOffset;
+				}
+				return {
+					value: new E(r),
+					nextOffset: i
+				};
+			}
+			let { value: r, nextOffset: i } = Y(e, t, a), o = Number(r);
+			i + o > e.byteLength && J("text string extends beyond input");
+			let s = new Uint8Array(e.buffer, e.byteOffset + i, o), c;
+			try {
+				c = cn.decode(s);
+			} catch {
+				J("invalid UTF-8 sequence in text string");
+			}
+			return {
+				value: new F(c),
+				nextOffset: i + o
+			};
+		}
+		case 4: {
+			if (a === 31) {
+				let r = [], i = t;
+				for (;;) {
+					if (i >= e.byteLength && J("unexpected end of indefinite array"), e.getUint8(i) === 255) {
+						i++;
+						break;
+					}
+					let t = X(e, i, n);
+					r.push(t.value), i = t.nextOffset;
+				}
+				return {
+					value: new D(r, { indefiniteLength: !0 }),
+					nextOffset: i
+				};
+			}
+			let { value: r, nextOffset: i } = Y(e, t, a), o = Number(r), s = [], c = i;
+			for (let t = 0; t < o; t++) {
+				let t = X(e, c, n);
+				s.push(t.value), c = t.nextOffset;
+			}
+			return {
+				value: new D(s),
+				nextOffset: c
+			};
+		}
+		case 5: {
+			if (a === 31) {
+				let r = [], i = t;
+				for (;;) {
+					if (i >= e.byteLength && J("unexpected end of indefinite map"), e.getUint8(i) === 255) {
+						i++;
+						break;
+					}
+					let t = X(e, i, n);
+					i = t.nextOffset;
+					let a = X(e, i, n);
+					i = a.nextOffset, r.push([t.value, a.value]);
+				}
+				return {
+					value: new O(r, { indefiniteLength: !0 }),
+					nextOffset: i
+				};
+			}
+			let { value: r, nextOffset: i } = Y(e, t, a), o = Number(r), s = [], c = i;
+			for (let t = 0; t < o; t++) {
+				let t = X(e, c, n);
+				c = t.nextOffset;
+				let r = X(e, c, n);
+				c = r.nextOffset, s.push([t.value, r.value]);
+			}
+			return {
+				value: new O(s),
+				nextOffset: c
+			};
+		}
+		case 6: {
+			a === 31 && J("tags cannot use indefinite-length encoding");
+			let { value: r, nextOffset: i } = Y(e, t, a), o = X(e, i, n);
+			for (let e of [...n?.extensions ?? [], ...Z]) if (e.parseTag) {
+				let t = e.parseTag(r, o.value);
+				if (t !== void 0) return {
+					value: t,
+					nextOffset: o.nextOffset
+				};
+			}
+			return {
+				value: new C(r, o.value),
+				nextOffset: o.nextOffset
+			};
+		}
+		case 7:
+			if (a <= 19) return {
+				value: new k(a),
+				nextOffset: t
+			};
+			if (a === 20) return {
+				value: k.FALSE,
+				nextOffset: t
+			};
+			if (a === 21) return {
+				value: k.TRUE,
+				nextOffset: t
+			};
+			if (a === 22) return {
+				value: k.NULL,
+				nextOffset: t
+			};
+			if (a === 23) return {
+				value: k.UNDEFINED,
+				nextOffset: t
+			};
+			if (a === 24) {
+				t + 1 > e.byteLength && J("unexpected end of input");
+				let n = e.getUint8(t);
+				return n < 32 && J(`simple value ${n} must be encoded in initial byte (0–31 reserved for extended encoding)`), {
+					value: new k(n),
+					nextOffset: t + 1
+				};
+			}
+			return a === 25 ? (t + 2 > e.byteLength && J("unexpected end of input"), {
+				value: new S(te(e.getUint16(t, !1)), { precision: "half" }),
+				nextOffset: t + 2
+			}) : a === 26 ? (t + 4 > e.byteLength && J("unexpected end of input"), {
+				value: new S(e.getFloat32(t, !1), { precision: "single" }),
+				nextOffset: t + 4
+			}) : a === 27 ? (t + 8 > e.byteLength && J("unexpected end of input"), {
+				value: new S(e.getFloat64(t, !1), { precision: "double" }),
+				nextOffset: t + 8
+			}) : (a < 31 && J(`reserved additional info value in major type 7: ${a}`), J("unexpected break code outside indefinite-length item"));
+	}
+	return J(`unknown major type: ${i}`);
+}
+function un(e) {
+	if (e instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && e instanceof SharedArrayBuffer) return new Uint8Array(e);
+	if (ArrayBuffer.isView(e)) return new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+	throw TypeError("expected ArrayBufferView or ArrayBufferLike");
+}
+function dn(e, t) {
+	let n = un(e), r = new DataView(n.buffer, n.byteOffset, n.byteLength), i = t?.offset ?? 0;
+	if (!Number.isInteger(i) || i < 0 || i > r.byteLength) throw RangeError(`CBOR decode offset must be an integer between 0 and ${r.byteLength}`);
+	let { value: a, nextOffset: o } = X(r, i, t);
+	return !t?.allowTrailing && o !== r.byteLength && J(`${r.byteLength - o} trailing byte(s) after end of CBOR item`), a;
+}
+//#endregion
+//#region src/extensions/cbordata.ts
+var fn = 24n, Z = [
+	bt,
+	Pt,
+	Lt,
+	sn,
+	{
+		tagNumbers: [fn],
+		parseTag(e, t) {
+			if (e === 24n && t instanceof w) try {
+				return new C(fn, new A([dn(t.value)]));
+			} catch {
+				return;
+			}
+		}
+	}
+];
+//#endregion
+//#region src/js/fromJS.ts
+function Q(e, t) {
+	if (t?.replacer) {
+		let { replacer: n, ...r } = t, i = hn(e, n, r.extensions, r.undefinedOmits);
+		return i === l ? k.UNDEFINED : Q(i, Object.keys(r).length > 0 ? r : void 0);
+	}
+	return pn(e, t, !0);
+}
+function pn(e, t, n) {
+	for (let n of [...t?.extensions ?? [], ...Z]) if (n.fromJS) {
+		let r = n.fromJS(e, t ?? {});
+		if (r !== void 0) return r;
+	}
+	if (n && typeof e == "object" && e && c.symbol in e) {
+		let n = e[c.symbol], r = pn(e, t, !1);
+		for (let e of [...t?.extensions ?? [], ...Z]) if (e.parseTag) {
+			let t = e.parseTag(n, r);
+			if (t !== void 0) return t;
+		}
+		return new C(n, r);
+	}
+	if (e instanceof c.Null) return k.NULL;
+	if (e instanceof c.Undefined) return k.UNDEFINED;
+	if (e instanceof u) return new k(e.value);
+	if (e === null) return k.NULL;
+	if (e === void 0) return k.UNDEFINED;
+	if (e === !0) return k.TRUE;
+	if (e === !1) return k.FALSE;
+	if (typeof e == "bigint") return e > 18446744073709551615n ? new M(e) : e < -18446744073709551616n ? new N(e) : e >= 0n ? new g(e) : new _(e);
+	if (typeof e == "number") return (t?.encodeIntegerAs ?? "int") === "int" && Number.isInteger(e) && !Object.is(e, -0) ? e >= 0 ? new g(BigInt(e)) : new _(BigInt(e)) : new S(e);
+	if (typeof e == "string") return new F(e);
+	if (e instanceof Number || e instanceof Boolean || e instanceof String || Object.prototype.toString.call(e) === "[object BigInt]") return pn(e.valueOf(), t, !1);
+	if (e instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && e instanceof SharedArrayBuffer) return new w(new Uint8Array(e));
+	if (ArrayBuffer.isView(e)) return e instanceof Uint8Array && t?.uint8ArrayAs === "array" ? new D(Array.from(e, (e) => new g(BigInt(e)))) : new w(new Uint8Array(e.buffer, e.byteOffset, e.byteLength));
+	if (e instanceof $) return new O([...e].map(([e, n]) => [Q(e, t), Q(n, t)]));
+	if (Array.isArray(e)) return new D(e.map((e) => Q(e, t)));
+	if (typeof e == "object") {
+		let n = [];
+		for (let [r, i] of Object.entries(e)) n.push([new F(r), Q(i, t)]);
+		return new O(n);
+	}
+	throw TypeError(`fromJS: unsupported value type: ${typeof e}`);
+}
+function mn(e) {
+	return ArrayBuffer.isView(e) || e instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && e instanceof SharedArrayBuffer || e instanceof Number || e instanceof Boolean || e instanceof String || Object.prototype.toString.call(e) === "[object BigInt]" || e instanceof c.Null || e instanceof c.Undefined || e instanceof u;
+}
+function hn(e, t, n, r) {
+	let i = [...n ?? [], ...Z];
+	function a(e) {
+		return e === l || r === !0 && e === void 0;
+	}
+	if (Array.isArray(t)) {
+		let n = t.map(String);
+		function r(e) {
+			if (typeof e != "object" || !e) return e;
+			if (e instanceof $) return $.from(e, ([e, t]) => [e, r(t)]);
+			if (Array.isArray(e)) return e.map(r);
+			if (c.symbol in e || mn(e) || i.some((t) => t.isJSType?.(e))) return e;
+			let t = Object.getPrototypeOf(e);
+			if (t === Object.prototype || t === null) {
+				let t = e.toJSON;
+				if (typeof t == "function") return r(t.call(e));
+			}
+			let a = {};
+			for (let t of n) Object.prototype.hasOwnProperty.call(e, t) && (a[t] = r(e[t]));
+			return a;
+		}
+		return r(e);
+	}
+	let o = t;
+	function s(e, t, n) {
+		if (typeof e == "object" && e && !(e instanceof $)) {
+			let n = Object.getPrototypeOf(e);
+			if (n === Object.prototype || n === null) {
+				let n = e.toJSON;
+				typeof n == "function" && (e = n.call(e, t));
+			}
+		}
+		if (e = o.call(n, t, e), typeof e == "object" && e) {
+			if (c.symbol in e) return e;
+			if (e instanceof $) {
+				let t = new $();
+				for (let [n, r] of e) {
+					let i = s(r, n, e);
+					a(i) || t.push([n, i]);
+				}
+				return t;
+			}
+			if (Array.isArray(e)) return e.map((t, n) => {
+				let r = s(t, String(n), e);
+				return a(r) ? null : r;
+			});
+			if (mn(e) || i.some((t) => t.isJSType?.(e))) return e;
+			let t = {};
+			for (let n of Object.keys(e)) {
+				let r = s(e[n], n, e);
+				a(r) || (t[n] = r);
+			}
+			return t;
+		}
+		return e;
+	}
+	return s(e, "", { "": e });
+}
+//#endregion
+//#region src/mapEntries.ts
+var $ = class extends Array {
+	toJSON() {
+		let e = {};
+		for (let [t, n] of this) {
+			let r = typeof t == "string" ? t : Q(t).toEDN();
+			r === "__proto__" ? Object.defineProperty(e, r, {
+				value: n,
+				writable: !0,
+				enumerable: !0,
+				configurable: !0
+			}) : e[r] = n;
+		}
+		return e;
+	}
+};
+//#endregion
+export { l as C, n as D, c as E, u as S, t as T, C as _, xt as a, g as b, N as c, k as d, O as f, w as g, T as h, dn as i, M as l, E as m, hn as n, F as o, D as p, Q as r, He as s, $ as t, A as u, S as v, e as w, d as x, _ as y };
+
+//# sourceMappingURL=mapEntries-D5MWtXqq.js.map