@flickfyi/flkr 0.0.0 → 0.0.118

package/node_modules/@flickfyi/identity/dist/cwt-tfd4xMR_.js

@@ -1,3397 +0,0 @@
-import { A as isBytes, C as bytesToHex, D as copyBytes, E as concatBytes$1, F as sha512, H as randomBytes$1, I as abytes$1, M as randomBytes, N as validateObject, T as bytesToNumberLE, V as concatBytes, _ as abool, a as normalizeZ, c as FpLegendre, d as isNegativeLE, h as aInRange, k as hexToBytes, m as pow2, n as createCurveFields, p as mod, r as createKeygen, s as validatePointCons, t as ScalarMultiplier, v as abytes, y as asafenumber } from "./curve-CpcHwjN8.js";
-import { i as base64urlnopad, r as base64url } from "./base-ClGB6hXM.js";
-import { z } from "zod";
-import { traceOperationSync } from "@flickfyi/rwsdk-extensions/otel";
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/is.js
-var objectTypeNames = [
-	"Object",
-	"RegExp",
-	"Date",
-	"Error",
-	"Map",
-	"Set",
-	"WeakMap",
-	"WeakSet",
-	"ArrayBuffer",
-	"SharedArrayBuffer",
-	"DataView",
-	"Promise",
-	"URL",
-	"HTMLElement",
-	"Int8Array",
-	"Uint8ClampedArray",
-	"Int16Array",
-	"Uint16Array",
-	"Int32Array",
-	"Uint32Array",
-	"Float32Array",
-	"Float64Array",
-	"BigInt64Array",
-	"BigUint64Array",
-	"Tagged"
-];
-/**
-* @param {any} value
-* @returns {string}
-*/
-function is(value) {
-	if (value === null) return "null";
-	if (value === void 0) return "undefined";
-	if (value === true || value === false) return "boolean";
-	const typeOf = typeof value;
-	if (typeOf === "string" || typeOf === "number" || typeOf === "bigint" || typeOf === "symbol") return typeOf;
-	if (typeOf === "function") return "Function";
-	if (Array.isArray(value)) return "Array";
-	if (value instanceof Uint8Array) return "Uint8Array";
-	if (value.constructor === Object) return "Object";
-	const objectType = getObjectType(value);
-	if (objectType) return objectType;
-	return "Object";
-}
-/**
-* @param {any} value
-* @returns {string|undefined}
-*/
-function getObjectType(value) {
-	const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
-	if (objectTypeNames.includes(objectTypeName)) return objectTypeName;
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/token.js
-var Type = class {
-	/**
-	* @param {number} major
-	* @param {string} name
-	* @param {boolean} terminal
-	*/
-	constructor(major, name, terminal) {
-		this.major = major;
-		this.majorEncoded = major << 5;
-		this.name = name;
-		this.terminal = terminal;
-	}
-	toString() {
-		return `Type[${this.major}].${this.name}`;
-	}
-	/**
-	* @param {Type} typ
-	* @returns {number}
-	*/
-	compare(typ) {
-		return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
-	}
-	/**
-	* Check equality between two Type instances. Safe to use across different
-	* copies of the Type class (e.g., when bundlers duplicate the module).
-	* (major, name) uniquely identifies a Type; terminal is implied by these.
-	* @param {Type} a
-	* @param {Type} b
-	* @returns {boolean}
-	*/
-	static equals(a, b) {
-		return a === b || a.major === b.major && a.name === b.name;
-	}
-};
-Type.uint = new Type(0, "uint", true);
-Type.negint = new Type(1, "negint", true);
-Type.bytes = new Type(2, "bytes", true);
-Type.string = new Type(3, "string", true);
-Type.array = new Type(4, "array", false);
-Type.map = new Type(5, "map", false);
-Type.tag = new Type(6, "tag", false);
-Type.float = new Type(7, "float", true);
-Type.false = new Type(7, "false", true);
-Type.true = new Type(7, "true", true);
-Type.null = new Type(7, "null", true);
-Type.undefined = new Type(7, "undefined", true);
-Type.break = new Type(7, "break", true);
-var Token = class {
-	/**
-	* @param {Type} type
-	* @param {any} [value]
-	* @param {number} [encodedLength]
-	*/
-	constructor(type, value, encodedLength) {
-		this.type = type;
-		this.value = value;
-		this.encodedLength = encodedLength;
-		/** @type {Uint8Array|undefined} */
-		this.encodedBytes = void 0;
-		/** @type {Uint8Array|undefined} */
-		this.byteValue = void 0;
-	}
-	toString() {
-		return `Token[${this.type}].${this.value}`;
-	}
-};
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/byte-utils.js
-var useBuffer = globalThis.process && !globalThis.process.browser && globalThis.Buffer && typeof globalThis.Buffer.isBuffer === "function";
-var textEncoder = new TextEncoder();
-/**
-* @typedef {import('../interface.js').ByteView} ByteView
-* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
-*/
-/**
-* @param {Uint8Array} buf
-* @returns {boolean}
-*/
-function isBuffer(buf) {
-	return useBuffer && globalThis.Buffer.isBuffer(buf);
-}
-/**
-* @param {ByteView|number[]} buf
-* @returns {ByteView}
-*/
-function asU8A(buf) {
-	if (!(buf instanceof Uint8Array)) return Uint8Array.from(buf);
-	return isBuffer(buf) ? new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength) : buf;
-}
-var FROM_STRING_THRESHOLD_BUFFER = 24;
-var FROM_STRING_THRESHOLD_TEXTENCODER = 200;
-var fromString = useBuffer ? (string) => {
-	return string.length >= FROM_STRING_THRESHOLD_BUFFER ? globalThis.Buffer.from(string) : utf8ToBytes(string);
-} : 
-/**
-* @param {string} string
-*/
-(string) => {
-	return string.length >= FROM_STRING_THRESHOLD_TEXTENCODER ? textEncoder.encode(string) : utf8ToBytes(string);
-};
-/**
-* Buffer variant not fast enough for what we need
-* @param {number[]} arr
-* @returns {AllocatedByteView}
-*/
-var fromArray = (arr) => {
-	return Uint8Array.from(arr);
-};
-var slice = useBuffer ? (bytes, start, end) => {
-	if (isBuffer(bytes)) return new Uint8Array(bytes.subarray(start, end));
-	return bytes.slice(start, end);
-} : 
-/**
-* @param {Uint8Array} bytes
-* @param {number} start
-* @param {number} end
-*/
-(bytes, start, end) => {
-	return bytes.slice(start, end);
-};
-var concat = useBuffer ? (chunks, length) => {
-	chunks = chunks.map((c) => c instanceof Uint8Array ? c : globalThis.Buffer.from(c));
-	return asU8A(globalThis.Buffer.concat(chunks, length));
-} : 
-/**
-* @param {ByteView[]} chunks
-* @param {number} length
-* @returns {AllocatedByteView}
-*/
-(chunks, length) => {
-	const out = new Uint8Array(length);
-	let off = 0;
-	for (let b of chunks) {
-		if (off + b.length > out.length) b = b.subarray(0, out.length - off);
-		out.set(b, off);
-		off += b.length;
-	}
-	return out;
-};
-var alloc = useBuffer ? (size) => {
-	return globalThis.Buffer.allocUnsafe(size);
-} : 
-/**
-* @param {number} size
-* @returns {AllocatedByteView}
-*/
-(size) => {
-	return new Uint8Array(size);
-};
-/**
-* @param {Uint8Array} b1
-* @param {Uint8Array} b2
-* @returns {number}
-*/
-function compare(b1, b2) {
-	if (isBuffer(b1) && isBuffer(b2)) return b1.compare(b2);
-	for (let i = 0; i < b1.length; i++) {
-		if (b1[i] === b2[i]) continue;
-		return b1[i] < b2[i] ? -1 : 1;
-	}
-	return 0;
-}
-/**
-* @param {string} str
-* @returns {number[]}
-*/
-function utf8ToBytes(str) {
-	const out = [];
-	let p = 0;
-	for (let i = 0; i < str.length; i++) {
-		let c = str.charCodeAt(i);
-		if (c < 128) out[p++] = c;
-		else if (c < 2048) {
-			out[p++] = c >> 6 | 192;
-			out[p++] = c & 63 | 128;
-		} else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
-			c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
-			out[p++] = c >> 18 | 240;
-			out[p++] = c >> 12 & 63 | 128;
-			out[p++] = c >> 6 & 63 | 128;
-			out[p++] = c & 63 | 128;
-		} else {
-			if (c >= 55296 && c <= 57343) c = 65533;
-			out[p++] = c >> 12 | 224;
-			out[p++] = c >> 6 & 63 | 128;
-			out[p++] = c & 63 | 128;
-		}
-	}
-	return out;
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/bl.js
-/**
-* Bl is a list of byte chunks, similar to https://github.com/rvagg/bl but for
-* writing rather than reading.
-* A Bl object accepts set() operations for individual bytes and copyTo() for
-* inserting byte arrays. These write operations don't automatically increment
-* the internal cursor so its "length" won't be changed. Instead, increment()
-* must be called to extend its length to cover the inserted data.
-* The toBytes() call will convert all internal memory to a single Uint8Array of
-* the correct length, truncating any data that is stored but hasn't been
-* included by an increment().
-* get() can retrieve a single byte.
-* All operations (except toBytes()) take an "offset" argument that will perform
-* the write at the offset _from the current cursor_. For most operations this
-* will be `0` to write at the current cursor position but it can be ahead of
-* the current cursor. Negative offsets probably work but are untested.
-*/
-/**
-* @typedef {import('../interface.js').ByteView} ByteView
-* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
-*/
-var defaultChunkSize = 256;
-var Bl = class {
-	/**
-	* @param {number} [chunkSize]
-	*/
-	constructor(chunkSize = defaultChunkSize) {
-		this.chunkSize = chunkSize;
-		/** @type {number} */
-		this.cursor = 0;
-		/** @type {number} */
-		this.maxCursor = -1;
-		/** @type {(ByteView|number[])[]} */
-		this.chunks = [];
-		/** @type {ByteView|number[]|null} */
-		this._initReuseChunk = null;
-	}
-	reset() {
-		this.cursor = 0;
-		this.maxCursor = -1;
-		if (this.chunks.length) this.chunks = [];
-		if (this._initReuseChunk !== null) {
-			this.chunks.push(this._initReuseChunk);
-			this.maxCursor = this._initReuseChunk.length - 1;
-		}
-	}
-	/**
-	* @param {ByteView|number[]} bytes
-	*/
-	push(bytes) {
-		let topChunk = this.chunks[this.chunks.length - 1];
-		if (this.cursor + bytes.length <= this.maxCursor + 1) {
-			const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
-			topChunk.set(bytes, chunkPos);
-		} else {
-			if (topChunk) {
-				const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
-				if (chunkPos < topChunk.length) {
-					this.chunks[this.chunks.length - 1] = topChunk.subarray(0, chunkPos);
-					this.maxCursor = this.cursor - 1;
-				}
-			}
-			if (bytes.length < 64 && bytes.length < this.chunkSize) {
-				topChunk = alloc(this.chunkSize);
-				this.chunks.push(topChunk);
-				this.maxCursor += topChunk.length;
-				if (this._initReuseChunk === null) this._initReuseChunk = topChunk;
-				topChunk.set(bytes, 0);
-			} else {
-				this.chunks.push(bytes);
-				this.maxCursor += bytes.length;
-			}
-		}
-		this.cursor += bytes.length;
-	}
-	/**
-	* @param {boolean} [reset]
-	* @returns {AllocatedByteView}
-	*/
-	toBytes(reset = false) {
-		let byts;
-		if (this.chunks.length === 1) {
-			const chunk = this.chunks[0];
-			if (reset && this.cursor > chunk.length / 2) {
-				byts = this.cursor === chunk.length ? chunk : chunk.subarray(0, this.cursor);
-				this._initReuseChunk = null;
-				this.chunks = [];
-			} else byts = slice(chunk, 0, this.cursor);
-		} else byts = concat(this.chunks, this.cursor);
-		if (reset) this.reset();
-		return byts;
-	}
-};
-/**
-* U8Bl is a buffer list that writes directly to a user-provided Uint8Array.
-* It provides the same interface as Bl but writes to a fixed destination.
-* @template {ArrayBufferLike} T
-*/
-var U8Bl = class {
-	/**
-	* @param {Uint8Array<T>} dest
-	*/
-	constructor(dest) {
-		this.dest = dest;
-		/** @type {number} */
-		this.cursor = 0;
-		/** @type {Array<Uint8Array<T>>} */
-		this.chunks = [dest];
-	}
-	reset() {
-		this.cursor = 0;
-	}
-	/**
-	* @param {ByteView|number[]} bytes
-	*/
-	push(bytes) {
-		if (this.cursor + bytes.length > this.dest.length) throw new Error("write out of bounds, destination buffer is too small");
-		this.dest.set(bytes, this.cursor);
-		this.cursor += bytes.length;
-	}
-	/**
-	* @param {boolean} [reset]
-	* @returns {Uint8Array<T>}
-	*/
-	toBytes(reset = false) {
-		const byts = this.dest.subarray(0, this.cursor);
-		if (reset) this.reset();
-		return byts;
-	}
-};
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/common.js
-var decodeErrPrefix = "CBOR decode error:";
-var encodeErrPrefix = "CBOR encode error:";
-var uintMinorPrefixBytes = [];
-uintMinorPrefixBytes[23] = 1;
-uintMinorPrefixBytes[24] = 2;
-uintMinorPrefixBytes[25] = 3;
-uintMinorPrefixBytes[26] = 5;
-uintMinorPrefixBytes[27] = 9;
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} need
-*/
-function assertEnoughData(data, pos, need) {
-	if (data.length - pos < need) throw new Error(`${decodeErrPrefix} not enough data for type`);
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/0uint.js
-var uintBoundaries = [
-	24,
-	256,
-	65536,
-	4294967296,
-	BigInt("18446744073709551616")
-];
-/**
-* @typedef {import('../interface.js').ByteWriter} ByteWriter
-* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
-*/
-/**
-* @param {Uint8Array} data
-* @param {number} offset
-* @param {DecodeOptions} options
-* @returns {number}
-*/
-function readUint8(data, offset, options) {
-	assertEnoughData(data, offset, 1);
-	const value = data[offset];
-	if (options.strict === true && value < uintBoundaries[0]) throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-	return value;
-}
-/**
-* @param {Uint8Array} data
-* @param {number} offset
-* @param {DecodeOptions} options
-* @returns {number}
-*/
-function readUint16(data, offset, options) {
-	assertEnoughData(data, offset, 2);
-	const value = data[offset] << 8 | data[offset + 1];
-	if (options.strict === true && value < uintBoundaries[1]) throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-	return value;
-}
-/**
-* @param {Uint8Array} data
-* @param {number} offset
-* @param {DecodeOptions} options
-* @returns {number}
-*/
-function readUint32(data, offset, options) {
-	assertEnoughData(data, offset, 4);
-	const value = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-	if (options.strict === true && value < uintBoundaries[2]) throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-	return value;
-}
-/**
-* @param {Uint8Array} data
-* @param {number} offset
-* @param {DecodeOptions} options
-* @returns {number|bigint}
-*/
-function readUint64(data, offset, options) {
-	assertEnoughData(data, offset, 8);
-	const hi = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
-	const lo = data[offset + 4] * 16777216 + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7];
-	const value = (BigInt(hi) << BigInt(32)) + BigInt(lo);
-	if (options.strict === true && value < uintBoundaries[3]) throw new Error(`${decodeErrPrefix} integer encoded in more bytes than necessary (strict decode)`);
-	if (value <= Number.MAX_SAFE_INTEGER) return Number(value);
-	if (options.allowBigInt === true) return value;
-	throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeUint8(data, pos, _minor, options) {
-	return new Token(Type.uint, readUint8(data, pos + 1, options), 2);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeUint16(data, pos, _minor, options) {
-	return new Token(Type.uint, readUint16(data, pos + 1, options), 3);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeUint32(data, pos, _minor, options) {
-	return new Token(Type.uint, readUint32(data, pos + 1, options), 5);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeUint64(data, pos, _minor, options) {
-	return new Token(Type.uint, readUint64(data, pos + 1, options), 9);
-}
-/**
-* @param {ByteWriter} writer
-* @param {Token} token
-*/
-function encodeUint(writer, token) {
-	return encodeUintValue(writer, 0, token.value);
-}
-/**
-* @param {ByteWriter} writer
-* @param {number} major
-* @param {number|bigint} uint
-*/
-function encodeUintValue(writer, major, uint) {
-	if (uint < uintBoundaries[0]) {
-		const nuint = Number(uint);
-		writer.push([major | nuint]);
-	} else if (uint < uintBoundaries[1]) {
-		const nuint = Number(uint);
-		writer.push([major | 24, nuint]);
-	} else if (uint < uintBoundaries[2]) {
-		const nuint = Number(uint);
-		writer.push([
-			major | 25,
-			nuint >>> 8,
-			nuint & 255
-		]);
-	} else if (uint < uintBoundaries[3]) {
-		const nuint = Number(uint);
-		writer.push([
-			major | 26,
-			nuint >>> 24 & 255,
-			nuint >>> 16 & 255,
-			nuint >>> 8 & 255,
-			nuint & 255
-		]);
-	} else {
-		const buint = BigInt(uint);
-		if (buint < uintBoundaries[4]) {
-			const set = [
-				major | 27,
-				0,
-				0,
-				0,
-				0,
-				0,
-				0,
-				0
-			];
-			let lo = Number(buint & BigInt(4294967295));
-			let hi = Number(buint >> BigInt(32) & BigInt(4294967295));
-			set[8] = lo & 255;
-			lo = lo >> 8;
-			set[7] = lo & 255;
-			lo = lo >> 8;
-			set[6] = lo & 255;
-			lo = lo >> 8;
-			set[5] = lo & 255;
-			set[4] = hi & 255;
-			hi = hi >> 8;
-			set[3] = hi & 255;
-			hi = hi >> 8;
-			set[2] = hi & 255;
-			hi = hi >> 8;
-			set[1] = hi & 255;
-			writer.push(set);
-		} else throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`);
-	}
-}
-/**
-* @param {Token} token
-* @returns {number}
-*/
-encodeUint.encodedSize = function encodedSize(token) {
-	return encodeUintValue.encodedSize(token.value);
-};
-/**
-* @param {number} uint
-* @returns {number}
-*/
-encodeUintValue.encodedSize = function encodedSize(uint) {
-	if (uint < uintBoundaries[0]) return 1;
-	if (uint < uintBoundaries[1]) return 2;
-	if (uint < uintBoundaries[2]) return 3;
-	if (uint < uintBoundaries[3]) return 5;
-	return 9;
-};
-/**
-* @param {Token} tok1
-* @param {Token} tok2
-* @returns {number}
-*/
-encodeUint.compareTokens = function compareTokens(tok1, tok2) {
-	return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : 0;
-};
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/1negint.js
-/**
-* @typedef {import('../interface.js').ByteWriter} ByteWriter
-* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
-*/
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeNegint8(data, pos, _minor, options) {
-	return new Token(Type.negint, -1 - readUint8(data, pos + 1, options), 2);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeNegint16(data, pos, _minor, options) {
-	return new Token(Type.negint, -1 - readUint16(data, pos + 1, options), 3);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeNegint32(data, pos, _minor, options) {
-	return new Token(Type.negint, -1 - readUint32(data, pos + 1, options), 5);
-}
-var neg1b$1 = BigInt(-1);
-var pos1b$1 = BigInt(1);
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeNegint64(data, pos, _minor, options) {
-	const int = readUint64(data, pos + 1, options);
-	if (typeof int !== "bigint") {
-		const value = -1 - int;
-		if (value >= Number.MIN_SAFE_INTEGER) return new Token(Type.negint, value, 9);
-	}
-	if (options.allowBigInt !== true) throw new Error(`${decodeErrPrefix} integers outside of the safe integer range are not supported`);
-	return new Token(Type.negint, neg1b$1 - BigInt(int), 9);
-}
-/**
-* @param {ByteWriter} writer
-* @param {Token} token
-*/
-function encodeNegint(writer, token) {
-	const negint = token.value;
-	const unsigned = typeof negint === "bigint" ? negint * neg1b$1 - pos1b$1 : negint * -1 - 1;
-	encodeUintValue(writer, token.type.majorEncoded, unsigned);
-}
-/**
-* @param {Token} token
-* @returns {number}
-*/
-encodeNegint.encodedSize = function encodedSize(token) {
-	const negint = token.value;
-	const unsigned = typeof negint === "bigint" ? negint * neg1b$1 - pos1b$1 : negint * -1 - 1;
-	if (unsigned < uintBoundaries[0]) return 1;
-	if (unsigned < uintBoundaries[1]) return 2;
-	if (unsigned < uintBoundaries[2]) return 3;
-	if (unsigned < uintBoundaries[3]) return 5;
-	return 9;
-};
-/**
-* @param {Token} tok1
-* @param {Token} tok2
-* @returns {number}
-*/
-encodeNegint.compareTokens = function compareTokens(tok1, tok2) {
-	return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : 0;
-};
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/2bytes.js
-/**
-* @typedef {import('../interface.js').ByteWriter} ByteWriter
-* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
-*/
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} prefix
-* @param {number} length
-* @returns {Token}
-*/
-function toToken$3(data, pos, prefix, length) {
-	assertEnoughData(data, pos, prefix + length);
-	const buf = data.slice(pos + prefix, pos + prefix + length);
-	return new Token(Type.bytes, buf, prefix + length);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} minor
-* @param {DecodeOptions} _options
-* @returns {Token}
-*/
-function decodeBytesCompact(data, pos, minor, _options) {
-	return toToken$3(data, pos, 1, minor);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeBytes8(data, pos, _minor, options) {
-	return toToken$3(data, pos, 2, readUint8(data, pos + 1, options));
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeBytes16(data, pos, _minor, options) {
-	return toToken$3(data, pos, 3, readUint16(data, pos + 1, options));
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeBytes32(data, pos, _minor, options) {
-	return toToken$3(data, pos, 5, readUint32(data, pos + 1, options));
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeBytes64(data, pos, _minor, options) {
-	const l = readUint64(data, pos + 1, options);
-	if (typeof l === "bigint") throw new Error(`${decodeErrPrefix} 64-bit integer bytes lengths not supported`);
-	return toToken$3(data, pos, 9, l);
-}
-/**
-* `encodedBytes` allows for caching when we do a byte version of a string
-* for key sorting purposes
-* @param {Token} token
-* @returns {Uint8Array}
-*/
-function tokenBytes(token) {
-	if (token.encodedBytes === void 0) token.encodedBytes = Type.equals(token.type, Type.string) ? fromString(token.value) : token.value;
-	return token.encodedBytes;
-}
-/**
-* @param {ByteWriter} writer
-* @param {Token} token
-*/
-function encodeBytes(writer, token) {
-	const bytes = tokenBytes(token);
-	encodeUintValue(writer, token.type.majorEncoded, bytes.length);
-	writer.push(bytes);
-}
-/**
-* @param {Token} token
-* @returns {number}
-*/
-encodeBytes.encodedSize = function encodedSize(token) {
-	const bytes = tokenBytes(token);
-	return encodeUintValue.encodedSize(bytes.length) + bytes.length;
-};
-/**
-* @param {Token} tok1
-* @param {Token} tok2
-* @returns {number}
-*/
-encodeBytes.compareTokens = function compareTokens(tok1, tok2) {
-	return compareBytes(tokenBytes(tok1), tokenBytes(tok2));
-};
-/**
-* @param {Uint8Array} b1
-* @param {Uint8Array} b2
-* @returns {number}
-*/
-function compareBytes(b1, b2) {
-	return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare(b1, b2);
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/3string.js
-var textDecoder = new TextDecoder();
-var ASCII_THRESHOLD = 32;
-/**
-* @typedef {import('../interface.js').ByteWriter} ByteWriter
-* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
-*/
-/**
-* Decode UTF-8 bytes to string. For short ASCII strings (common case for map keys),
-* a simple loop is faster than TextDecoder.
-* @param {Uint8Array} bytes
-* @param {number} start
-* @param {number} end
-* @returns {string}
-*/
-function toStr(bytes, start, end) {
-	if (end - start < ASCII_THRESHOLD) {
-		let str = "";
-		for (let i = start; i < end; i++) {
-			const c = bytes[i];
-			if (c & 128) return textDecoder.decode(bytes.subarray(start, end));
-			str += String.fromCharCode(c);
-		}
-		return str;
-	}
-	return textDecoder.decode(bytes.subarray(start, end));
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} prefix
-* @param {number} length
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function toToken$2(data, pos, prefix, length, options) {
-	const totLength = prefix + length;
-	assertEnoughData(data, pos, totLength);
-	const tok = new Token(Type.string, toStr(data, pos + prefix, pos + totLength), totLength);
-	if (options.retainStringBytes === true) tok.byteValue = data.slice(pos + prefix, pos + totLength);
-	return tok;
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeStringCompact(data, pos, minor, options) {
-	return toToken$2(data, pos, 1, minor, options);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeString8(data, pos, _minor, options) {
-	return toToken$2(data, pos, 2, readUint8(data, pos + 1, options), options);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeString16(data, pos, _minor, options) {
-	return toToken$2(data, pos, 3, readUint16(data, pos + 1, options), options);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeString32(data, pos, _minor, options) {
-	return toToken$2(data, pos, 5, readUint32(data, pos + 1, options), options);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeString64(data, pos, _minor, options) {
-	const l = readUint64(data, pos + 1, options);
-	if (typeof l === "bigint") throw new Error(`${decodeErrPrefix} 64-bit integer string lengths not supported`);
-	return toToken$2(data, pos, 9, l, options);
-}
-var encodeString = encodeBytes;
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/4array.js
-/**
-* @typedef {import('../interface.js').ByteWriter} ByteWriter
-* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
-*/
-/**
-* @param {Uint8Array} _data
-* @param {number} _pos
-* @param {number} prefix
-* @param {number} length
-* @returns {Token}
-*/
-function toToken$1(_data, _pos, prefix, length) {
-	return new Token(Type.array, length, prefix);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} minor
-* @param {DecodeOptions} _options
-* @returns {Token}
-*/
-function decodeArrayCompact(data, pos, minor, _options) {
-	return toToken$1(data, pos, 1, minor);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeArray8(data, pos, _minor, options) {
-	return toToken$1(data, pos, 2, readUint8(data, pos + 1, options));
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeArray16(data, pos, _minor, options) {
-	return toToken$1(data, pos, 3, readUint16(data, pos + 1, options));
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeArray32(data, pos, _minor, options) {
-	return toToken$1(data, pos, 5, readUint32(data, pos + 1, options));
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeArray64(data, pos, _minor, options) {
-	const l = readUint64(data, pos + 1, options);
-	if (typeof l === "bigint") throw new Error(`${decodeErrPrefix} 64-bit integer array lengths not supported`);
-	return toToken$1(data, pos, 9, l);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeArrayIndefinite(data, pos, _minor, options) {
-	if (options.allowIndefinite === false) throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-	return toToken$1(data, pos, 1, Infinity);
-}
-/**
-* @param {ByteWriter} writer
-* @param {Token} token
-*/
-function encodeArray(writer, token) {
-	encodeUintValue(writer, Type.array.majorEncoded, token.value);
-}
-encodeArray.compareTokens = encodeUint.compareTokens;
-/**
-* @param {Token} token
-* @returns {number}
-*/
-encodeArray.encodedSize = function encodedSize(token) {
-	return encodeUintValue.encodedSize(token.value);
-};
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/5map.js
-/**
-* @typedef {import('../interface.js').ByteWriter} ByteWriter
-* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
-*/
-/**
-* @param {Uint8Array} _data
-* @param {number} _pos
-* @param {number} prefix
-* @param {number} length
-* @returns {Token}
-*/
-function toToken(_data, _pos, prefix, length) {
-	return new Token(Type.map, length, prefix);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} minor
-* @param {DecodeOptions} _options
-* @returns {Token}
-*/
-function decodeMapCompact(data, pos, minor, _options) {
-	return toToken(data, pos, 1, minor);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeMap8(data, pos, _minor, options) {
-	return toToken(data, pos, 2, readUint8(data, pos + 1, options));
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeMap16(data, pos, _minor, options) {
-	return toToken(data, pos, 3, readUint16(data, pos + 1, options));
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeMap32(data, pos, _minor, options) {
-	return toToken(data, pos, 5, readUint32(data, pos + 1, options));
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeMap64(data, pos, _minor, options) {
-	const l = readUint64(data, pos + 1, options);
-	if (typeof l === "bigint") throw new Error(`${decodeErrPrefix} 64-bit integer map lengths not supported`);
-	return toToken(data, pos, 9, l);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeMapIndefinite(data, pos, _minor, options) {
-	if (options.allowIndefinite === false) throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-	return toToken(data, pos, 1, Infinity);
-}
-/**
-* @param {ByteWriter} writer
-* @param {Token} token
-*/
-function encodeMap(writer, token) {
-	encodeUintValue(writer, Type.map.majorEncoded, token.value);
-}
-encodeMap.compareTokens = encodeUint.compareTokens;
-/**
-* @param {Token} token
-* @returns {number}
-*/
-encodeMap.encodedSize = function encodedSize(token) {
-	return encodeUintValue.encodedSize(token.value);
-};
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/6tag.js
-/**
-* @typedef {import('../interface.js').ByteWriter} ByteWriter
-* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
-*/
-/**
-* @param {Uint8Array} _data
-* @param {number} _pos
-* @param {number} minor
-* @param {DecodeOptions} _options
-* @returns {Token}
-*/
-function decodeTagCompact(_data, _pos, minor, _options) {
-	return new Token(Type.tag, minor, 1);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeTag8(data, pos, _minor, options) {
-	return new Token(Type.tag, readUint8(data, pos + 1, options), 2);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeTag16(data, pos, _minor, options) {
-	return new Token(Type.tag, readUint16(data, pos + 1, options), 3);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeTag32(data, pos, _minor, options) {
-	return new Token(Type.tag, readUint32(data, pos + 1, options), 5);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeTag64(data, pos, _minor, options) {
-	return new Token(Type.tag, readUint64(data, pos + 1, options), 9);
-}
-/**
-* @param {ByteWriter} writer
-* @param {Token} token
-*/
-function encodeTag(writer, token) {
-	encodeUintValue(writer, Type.tag.majorEncoded, token.value);
-}
-encodeTag.compareTokens = encodeUint.compareTokens;
-/**
-* @param {Token} token
-* @returns {number}
-*/
-encodeTag.encodedSize = function encodedSize(token) {
-	return encodeUintValue.encodedSize(token.value);
-};
-/**
-* @param {Uint8Array} _data
-* @param {number} _pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeUndefined(_data, _pos, _minor, options) {
-	if (options.allowUndefined === false) throw new Error(`${decodeErrPrefix} undefined values are not supported`);
-	else if (options.coerceUndefinedToNull === true) return new Token(Type.null, null, 1);
-	return new Token(Type.undefined, void 0, 1);
-}
-/**
-* @param {Uint8Array} _data
-* @param {number} _pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeBreak(_data, _pos, _minor, options) {
-	if (options.allowIndefinite === false) throw new Error(`${decodeErrPrefix} indefinite length items not allowed`);
-	return new Token(Type.break, void 0, 1);
-}
-/**
-* @param {number} value
-* @param {number} bytes
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function createToken(value, bytes, options) {
-	if (options) {
-		if (options.allowNaN === false && Number.isNaN(value)) throw new Error(`${decodeErrPrefix} NaN values are not supported`);
-		if (options.allowInfinity === false && (value === Infinity || value === -Infinity)) throw new Error(`${decodeErrPrefix} Infinity values are not supported`);
-	}
-	return new Token(Type.float, value, bytes);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeFloat16(data, pos, _minor, options) {
-	return createToken(readFloat16(data, pos + 1), 3, options);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeFloat32(data, pos, _minor, options) {
-	return createToken(readFloat32(data, pos + 1), 5, options);
-}
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} _minor
-* @param {DecodeOptions} options
-* @returns {Token}
-*/
-function decodeFloat64(data, pos, _minor, options) {
-	return createToken(readFloat64(data, pos + 1), 9, options);
-}
-/**
-* @param {ByteWriter} writer
-* @param {Token} token
-* @param {EncodeOptions} options
-*/
-function encodeFloat(writer, token, options) {
-	const float = token.value;
-	if (float === false) writer.push([Type.float.majorEncoded | 20]);
-	else if (float === true) writer.push([Type.float.majorEncoded | 21]);
-	else if (float === null) writer.push([Type.float.majorEncoded | 22]);
-	else if (float === void 0) writer.push([Type.float.majorEncoded | 23]);
-	else {
-		let decoded;
-		let success = false;
-		if (!options || options.float64 !== true) {
-			encodeFloat16(float);
-			decoded = readFloat16(ui8a, 1);
-			if (float === decoded || Number.isNaN(float)) {
-				ui8a[0] = 249;
-				writer.push(ui8a.slice(0, 3));
-				success = true;
-			} else {
-				encodeFloat32(float);
-				decoded = readFloat32(ui8a, 1);
-				if (float === decoded) {
-					ui8a[0] = 250;
-					writer.push(ui8a.slice(0, 5));
-					success = true;
-				}
-			}
-		}
-		if (!success) {
-			encodeFloat64(float);
-			decoded = readFloat64(ui8a, 1);
-			ui8a[0] = 251;
-			writer.push(ui8a.slice(0, 9));
-		}
-	}
-}
-/**
-* @param {Token} token
-* @param {EncodeOptions} options
-* @returns {number}
-*/
-encodeFloat.encodedSize = function encodedSize(token, options) {
-	const float = token.value;
-	if (float === false || float === true || float === null || float === void 0) return 1;
-	if (!options || options.float64 !== true) {
-		encodeFloat16(float);
-		let decoded = readFloat16(ui8a, 1);
-		if (float === decoded || Number.isNaN(float)) return 3;
-		encodeFloat32(float);
-		decoded = readFloat32(ui8a, 1);
-		if (float === decoded) return 5;
-	}
-	return 9;
-};
-var buffer = /* @__PURE__ */ new ArrayBuffer(9);
-var dataView = new DataView(buffer, 1);
-var ui8a = new Uint8Array(buffer, 0);
-/**
-* @param {number} inp
-*/
-function encodeFloat16(inp) {
-	if (inp === Infinity) dataView.setUint16(0, 31744, false);
-	else if (inp === -Infinity) dataView.setUint16(0, 64512, false);
-	else if (Number.isNaN(inp)) dataView.setUint16(0, 32256, false);
-	else {
-		dataView.setFloat32(0, inp);
-		const valu32 = dataView.getUint32(0);
-		const exponent = (valu32 & 2139095040) >> 23;
-		const mantissa = valu32 & 8388607;
-		if (exponent === 255) dataView.setUint16(0, 31744, false);
-		else if (exponent === 0) dataView.setUint16(0, (valu32 & 2147483648) >> 16 | mantissa >> 13, false);
-		else {
-			const logicalExponent = exponent - 127;
-			if (logicalExponent < -24) dataView.setUint16(0, 0);
-			else if (logicalExponent < -14) dataView.setUint16(0, (valu32 & 2147483648) >> 16 | 1 << 24 + logicalExponent, false);
-			else dataView.setUint16(0, (valu32 & 2147483648) >> 16 | logicalExponent + 15 << 10 | mantissa >> 13, false);
-		}
-	}
-}
-/**
-* @param {Uint8Array} ui8a
-* @param {number} pos
-* @returns {number}
-*/
-function readFloat16(ui8a, pos) {
-	if (ui8a.length - pos < 2) throw new Error(`${decodeErrPrefix} not enough data for float16`);
-	const half = (ui8a[pos] << 8) + ui8a[pos + 1];
-	if (half === 31744) return Infinity;
-	if (half === 64512) return -Infinity;
-	if (half === 32256) return NaN;
-	const exp = half >> 10 & 31;
-	const mant = half & 1023;
-	let val;
-	if (exp === 0) val = mant * 2 ** -24;
-	else if (exp !== 31) val = (mant + 1024) * 2 ** (exp - 25);
-	else val = mant === 0 ? Infinity : NaN;
-	return half & 32768 ? -val : val;
-}
-/**
-* @param {number} inp
-*/
-function encodeFloat32(inp) {
-	dataView.setFloat32(0, inp, false);
-}
-/**
-* @param {Uint8Array} ui8a
-* @param {number} pos
-* @returns {number}
-*/
-function readFloat32(ui8a, pos) {
-	if (ui8a.length - pos < 4) throw new Error(`${decodeErrPrefix} not enough data for float32`);
-	const offset = (ui8a.byteOffset || 0) + pos;
-	return new DataView(ui8a.buffer, offset, 4).getFloat32(0, false);
-}
-/**
-* @param {number} inp
-*/
-function encodeFloat64(inp) {
-	dataView.setFloat64(0, inp, false);
-}
-/**
-* @param {Uint8Array} ui8a
-* @param {number} pos
-* @returns {number}
-*/
-function readFloat64(ui8a, pos) {
-	if (ui8a.length - pos < 8) throw new Error(`${decodeErrPrefix} not enough data for float64`);
-	const offset = (ui8a.byteOffset || 0) + pos;
-	return new DataView(ui8a.buffer, offset, 8).getFloat64(0, false);
-}
-/**
-* @param {Token} _tok1
-* @param {Token} _tok2
-* @returns {number}
-*/
-encodeFloat.compareTokens = encodeUint.compareTokens;
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/jump.js
-/**
-* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
-* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
-*/
-/**
-* @param {Uint8Array} data
-* @param {number} pos
-* @param {number} minor
-*/
-function invalidMinor(data, pos, minor) {
-	throw new Error(`${decodeErrPrefix} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`);
-}
-/**
-* @param {string} msg
-* @returns {()=>any}
-*/
-function errorer(msg) {
-	return () => {
-		throw new Error(`${decodeErrPrefix} ${msg}`);
-	};
-}
-/** @type {((data:Uint8Array, pos:number, minor:number, options?:DecodeOptions) => any)[]} */
-var jump = [];
-for (let i = 0; i <= 23; i++) jump[i] = invalidMinor;
-jump[24] = decodeUint8;
-jump[25] = decodeUint16;
-jump[26] = decodeUint32;
-jump[27] = decodeUint64;
-jump[28] = invalidMinor;
-jump[29] = invalidMinor;
-jump[30] = invalidMinor;
-jump[31] = invalidMinor;
-for (let i = 32; i <= 55; i++) jump[i] = invalidMinor;
-jump[56] = decodeNegint8;
-jump[57] = decodeNegint16;
-jump[58] = decodeNegint32;
-jump[59] = decodeNegint64;
-jump[60] = invalidMinor;
-jump[61] = invalidMinor;
-jump[62] = invalidMinor;
-jump[63] = invalidMinor;
-for (let i = 64; i <= 87; i++) jump[i] = decodeBytesCompact;
-jump[88] = decodeBytes8;
-jump[89] = decodeBytes16;
-jump[90] = decodeBytes32;
-jump[91] = decodeBytes64;
-jump[92] = invalidMinor;
-jump[93] = invalidMinor;
-jump[94] = invalidMinor;
-jump[95] = errorer("indefinite length bytes/strings are not supported");
-for (let i = 96; i <= 119; i++) jump[i] = decodeStringCompact;
-jump[120] = decodeString8;
-jump[121] = decodeString16;
-jump[122] = decodeString32;
-jump[123] = decodeString64;
-jump[124] = invalidMinor;
-jump[125] = invalidMinor;
-jump[126] = invalidMinor;
-jump[127] = errorer("indefinite length bytes/strings are not supported");
-for (let i = 128; i <= 151; i++) jump[i] = decodeArrayCompact;
-jump[152] = decodeArray8;
-jump[153] = decodeArray16;
-jump[154] = decodeArray32;
-jump[155] = decodeArray64;
-jump[156] = invalidMinor;
-jump[157] = invalidMinor;
-jump[158] = invalidMinor;
-jump[159] = decodeArrayIndefinite;
-for (let i = 160; i <= 183; i++) jump[i] = decodeMapCompact;
-jump[184] = decodeMap8;
-jump[185] = decodeMap16;
-jump[186] = decodeMap32;
-jump[187] = decodeMap64;
-jump[188] = invalidMinor;
-jump[189] = invalidMinor;
-jump[190] = invalidMinor;
-jump[191] = decodeMapIndefinite;
-for (let i = 192; i <= 215; i++) jump[i] = decodeTagCompact;
-jump[216] = decodeTag8;
-jump[217] = decodeTag16;
-jump[218] = decodeTag32;
-jump[219] = decodeTag64;
-jump[220] = invalidMinor;
-jump[221] = invalidMinor;
-jump[222] = invalidMinor;
-jump[223] = invalidMinor;
-for (let i = 224; i <= 243; i++) jump[i] = errorer("simple values are not supported");
-jump[244] = invalidMinor;
-jump[245] = invalidMinor;
-jump[246] = invalidMinor;
-jump[247] = decodeUndefined;
-jump[248] = errorer("simple values are not supported");
-jump[249] = decodeFloat16;
-jump[250] = decodeFloat32;
-jump[251] = decodeFloat64;
-jump[252] = invalidMinor;
-jump[253] = invalidMinor;
-jump[254] = invalidMinor;
-jump[255] = decodeBreak;
-/** @type {Token[]} */
-var quick = [];
-for (let i = 0; i < 24; i++) quick[i] = new Token(Type.uint, i, 1);
-for (let i = -1; i >= -24; i--) quick[31 - i] = new Token(Type.negint, i, 1);
-quick[64] = new Token(Type.bytes, /* @__PURE__ */ new Uint8Array(0), 1);
-quick[96] = new Token(Type.string, "", 1);
-quick[128] = new Token(Type.array, 0, 1);
-quick[160] = new Token(Type.map, 0, 1);
-quick[244] = new Token(Type.false, false, 1);
-quick[245] = new Token(Type.true, true, 1);
-quick[246] = new Token(Type.null, null, 1);
-/**
-* @param {Token} token
-* @returns {AllocatedByteView|undefined}
-*/
-function quickEncodeToken(token) {
-	switch (token.type) {
-		case Type.false: return fromArray([244]);
-		case Type.true: return fromArray([245]);
-		case Type.null: return fromArray([246]);
-		case Type.bytes:
-			if (!token.value.length) return fromArray([64]);
-			return;
-		case Type.string:
-			if (token.value === "") return fromArray([96]);
-			return;
-		case Type.array:
-			if (token.value === 0) return fromArray([128]);
-			return;
-		case Type.map:
-			if (token.value === 0) return fromArray([160]);
-			return;
-		case Type.uint:
-			if (token.value < 24) return fromArray([Number(token.value)]);
-			return;
-		case Type.negint: if (token.value >= -24) return fromArray([31 - Number(token.value)]);
-	}
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/encode.js
-/**
-* @typedef {import('../interface.js').EncodeOptions} EncodeOptions
-* @typedef {import('../interface.js').OptionalTypeEncoder} OptionalTypeEncoder
-* @typedef {import('../interface.js').Reference} Reference
-* @typedef {import('../interface.js').StrictTypeEncoder} StrictTypeEncoder
-* @typedef {import('../interface.js').TokenTypeEncoder} TokenTypeEncoder
-* @typedef {import('../interface.js').TokenOrNestedTokens} TokenOrNestedTokens
-* @typedef {import('../interface.js').ByteWriter} ByteWriter
-* @typedef {import('../interface.js').ByteView} ByteView
-* @typedef {import('../interface.js').AllocatedByteView} AllocatedByteView
-*/
-/** @type {EncodeOptions} */
-var defaultEncodeOptions = {
-	float64: false,
-	mapSorter,
-	quickEncodeToken
-};
-/** @type {EncodeOptions} */
-var rfc8949EncodeOptions = Object.freeze({
-	mapSorter: rfc8949MapSorter,
-	quickEncodeToken
-});
-/** @returns {TokenTypeEncoder[]} */
-function makeCborEncoders() {
-	const encoders = [];
-	encoders[Type.uint.major] = encodeUint;
-	encoders[Type.negint.major] = encodeNegint;
-	encoders[Type.bytes.major] = encodeBytes;
-	encoders[Type.string.major] = encodeString;
-	encoders[Type.array.major] = encodeArray;
-	encoders[Type.map.major] = encodeMap;
-	encoders[Type.tag.major] = encodeTag;
-	encoders[Type.float.major] = encodeFloat;
-	return encoders;
-}
-var cborEncoders = makeCborEncoders();
-var defaultWriter = new Bl();
-/** @implements {Reference} */
-var Ref = class Ref {
-	/**
-	* @param {object|any[]} obj
-	* @param {Reference|undefined} parent
-	*/
-	constructor(obj, parent) {
-		this.obj = obj;
-		this.parent = parent;
-	}
-	/**
-	* @param {object|any[]} obj
-	* @returns {boolean}
-	*/
-	includes(obj) {
-		/** @type {Reference|undefined} */
-		let p = this;
-		do
-			if (p.obj === obj) return true;
-		while (p = p.parent);
-		return false;
-	}
-	/**
-	* @param {Reference|undefined} stack
-	* @param {object|any[]} obj
-	* @returns {Reference}
-	*/
-	static createCheck(stack, obj) {
-		if (stack && stack.includes(obj)) throw new Error(`${encodeErrPrefix} object contains circular references`);
-		return new Ref(obj, stack);
-	}
-};
-var simpleTokens = {
-	null: new Token(Type.null, null),
-	undefined: new Token(Type.undefined, void 0),
-	true: new Token(Type.true, true),
-	false: new Token(Type.false, false),
-	emptyArray: new Token(Type.array, 0),
-	emptyMap: new Token(Type.map, 0)
-};
-/** @type {{[typeName: string]: StrictTypeEncoder}} */
-var typeEncoders = {
-	/**
-	* @param {any} obj
-	* @param {string} _typ
-	* @param {EncodeOptions} _options
-	* @param {Reference} [_refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	number(obj, _typ, _options, _refStack) {
-		if (!Number.isInteger(obj) || !Number.isSafeInteger(obj)) return new Token(Type.float, obj);
-		else if (obj >= 0) return new Token(Type.uint, obj);
-		else return new Token(Type.negint, obj);
-	},
-	/**
-	* @param {any} obj
-	* @param {string} _typ
-	* @param {EncodeOptions} _options
-	* @param {Reference} [_refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	bigint(obj, _typ, _options, _refStack) {
-		if (obj >= BigInt(0)) return new Token(Type.uint, obj);
-		else return new Token(Type.negint, obj);
-	},
-	/**
-	* @param {any} obj
-	* @param {string} _typ
-	* @param {EncodeOptions} _options
-	* @param {Reference} [_refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	Uint8Array(obj, _typ, _options, _refStack) {
-		return new Token(Type.bytes, obj);
-	},
-	/**
-	* @param {any} obj
-	* @param {string} _typ
-	* @param {EncodeOptions} _options
-	* @param {Reference} [_refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	string(obj, _typ, _options, _refStack) {
-		return new Token(Type.string, obj);
-	},
-	/**
-	* @param {any} obj
-	* @param {string} _typ
-	* @param {EncodeOptions} _options
-	* @param {Reference} [_refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	boolean(obj, _typ, _options, _refStack) {
-		return obj ? simpleTokens.true : simpleTokens.false;
-	},
-	/**
-	* @param {any} _obj
-	* @param {string} _typ
-	* @param {EncodeOptions} _options
-	* @param {Reference} [_refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	null(_obj, _typ, _options, _refStack) {
-		return simpleTokens.null;
-	},
-	/**
-	* @param {any} _obj
-	* @param {string} _typ
-	* @param {EncodeOptions} _options
-	* @param {Reference} [_refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	undefined(_obj, _typ, _options, _refStack) {
-		return simpleTokens.undefined;
-	},
-	/**
-	* @param {any} obj
-	* @param {string} _typ
-	* @param {EncodeOptions} _options
-	* @param {Reference} [_refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	ArrayBuffer(obj, _typ, _options, _refStack) {
-		return new Token(Type.bytes, new Uint8Array(obj));
-	},
-	/**
-	* @param {any} obj
-	* @param {string} _typ
-	* @param {EncodeOptions} _options
-	* @param {Reference} [_refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	DataView(obj, _typ, _options, _refStack) {
-		return new Token(Type.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength));
-	},
-	/**
-	* @param {any} obj
-	* @param {string} _typ
-	* @param {EncodeOptions} options
-	* @param {Reference} [refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	Array(obj, _typ, options, refStack) {
-		if (!obj.length) {
-			if (options.addBreakTokens === true) return [simpleTokens.emptyArray, new Token(Type.break)];
-			return simpleTokens.emptyArray;
-		}
-		refStack = Ref.createCheck(refStack, obj);
-		const entries = [];
-		let i = 0;
-		for (const e of obj) entries[i++] = objectToTokens(e, options, refStack);
-		if (options.addBreakTokens) return [
-			new Token(Type.array, obj.length),
-			entries,
-			new Token(Type.break)
-		];
-		return [new Token(Type.array, obj.length), entries];
-	},
-	/**
-	* @param {any} obj
-	* @param {string} typ
-	* @param {EncodeOptions} options
-	* @param {Reference} [refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	Object(obj, typ, options, refStack) {
-		const isMap = typ !== "Object";
-		const keys = isMap ? obj.keys() : Object.keys(obj);
-		const maxLength = isMap ? obj.size : keys.length;
-		/** @type {undefined | [TokenOrNestedTokens, TokenOrNestedTokens][]} */
-		let entries;
-		if (maxLength) {
-			entries = new Array(maxLength);
-			refStack = Ref.createCheck(refStack, obj);
-			const skipUndefined = !isMap && options.ignoreUndefinedProperties;
-			let i = 0;
-			for (const key of keys) {
-				const value = isMap ? obj.get(key) : obj[key];
-				if (skipUndefined && value === void 0) continue;
-				entries[i++] = [objectToTokens(key, options, refStack), objectToTokens(value, options, refStack)];
-			}
-			if (i < maxLength) entries.length = i;
-		}
-		if (!entries?.length) {
-			if (options.addBreakTokens === true) return [simpleTokens.emptyMap, new Token(Type.break)];
-			return simpleTokens.emptyMap;
-		}
-		sortMapEntries(entries, options);
-		if (options.addBreakTokens) return [
-			new Token(Type.map, entries.length),
-			entries,
-			new Token(Type.break)
-		];
-		return [new Token(Type.map, entries.length), entries];
-	},
-	/**
-	* Encode a `Tagged` wrapper as a CBOR tag header followed by the encoded
-	* form of the wrapped value. The value is recursively tokenised through
-	* `objectToTokens()` so any registered `typeEncoders` apply to it.
-	*
-	* @param {any} obj
-	* @param {string} _typ
-	* @param {EncodeOptions} options
-	* @param {Reference} [refStack]
-	* @returns {TokenOrNestedTokens}
-	*/
-	Tagged(obj, _typ, options, refStack) {
-		return [new Token(Type.tag, obj.tag), objectToTokens(obj.value, options, refStack)];
-	}
-};
-typeEncoders.Map = typeEncoders.Object;
-typeEncoders.Buffer = typeEncoders.Uint8Array;
-for (const typ of "Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64".split(" ")) typeEncoders[`${typ}Array`] = typeEncoders.DataView;
-/**
-* @param {any} obj
-* @param {EncodeOptions} [options]
-* @param {Reference} [refStack]
-* @returns {TokenOrNestedTokens}
-*/
-function objectToTokens(obj, options = {}, refStack) {
-	const typ = is(obj);
-	const customTypeEncoder = options && options.typeEncoders && options.typeEncoders[typ] || typeEncoders[typ];
-	if (typeof customTypeEncoder === "function") {
-		const tokens = customTypeEncoder(obj, typ, options, refStack);
-		if (tokens != null) return tokens;
-	}
-	const typeEncoder = typeEncoders[typ];
-	if (!typeEncoder) throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
-	return typeEncoder(obj, typ, options, refStack);
-}
-/**
-* @param {TokenOrNestedTokens[]} entries
-* @param {EncodeOptions} options
-*/
-function sortMapEntries(entries, options) {
-	if (options.mapSorter) entries.sort(options.mapSorter);
-}
-/**
-* @param {(Token|Token[])[]} e1
-* @param {(Token|Token[])[]} e2
-* @returns {number}
-*/
-function mapSorter(e1, e2) {
-	const keyToken1 = Array.isArray(e1[0]) ? e1[0][0] : e1[0];
-	const keyToken2 = Array.isArray(e2[0]) ? e2[0][0] : e2[0];
-	if (keyToken1.type !== keyToken2.type) return keyToken1.type.compare(keyToken2.type);
-	const tcmp = cborEncoders[keyToken1.type.major].compareTokens(keyToken1, keyToken2);
-	if (tcmp === 0) console.warn("WARNING: complex key types used, CBOR key sorting guarantees are gone");
-	return tcmp;
-}
-/**
-* @typedef {Token & { _keyBytes?: AllocatedByteView }} TokenEx
-*
-* @param {(Token|Token[])[]} e1
-* @param {(Token|Token[])[]} e2
-* @returns {number}
-*/
-function rfc8949MapSorter(e1, e2) {
-	if (e1[0] instanceof Token && e2[0] instanceof Token) {
-		const t1 = e1[0];
-		const t2 = e2[0];
-		if (!t1._keyBytes) t1._keyBytes = encodeRfc8949(t1.value);
-		if (!t2._keyBytes) t2._keyBytes = encodeRfc8949(t2.value);
-		return compare(t1._keyBytes, t2._keyBytes);
-	}
-	throw new Error("rfc8949MapSorter: complex key types are not supported yet");
-}
-/**
-* @param {any} data
-* @returns {AllocatedByteView}
-*/
-function encodeRfc8949(data) {
-	return encodeCustom(data, cborEncoders, rfc8949EncodeOptions);
-}
-/**
-* @param {ByteWriter} writer
-* @param {TokenOrNestedTokens} tokens
-* @param {TokenTypeEncoder[]} encoders
-* @param {EncodeOptions} options
-*/
-function tokensToEncoded(writer, tokens, encoders, options) {
-	if (Array.isArray(tokens)) for (const token of tokens) tokensToEncoded(writer, token, encoders, options);
-	else encoders[tokens.type.major](writer, tokens, options);
-}
-var MAJOR_UINT = Type.uint.majorEncoded;
-var MAJOR_NEGINT = Type.negint.majorEncoded;
-var MAJOR_BYTES = Type.bytes.majorEncoded;
-var MAJOR_STRING = Type.string.majorEncoded;
-var MAJOR_ARRAY = Type.array.majorEncoded;
-var SIMPLE_FALSE = Type.float.majorEncoded | 20;
-var SIMPLE_TRUE = Type.float.majorEncoded | 21;
-var SIMPLE_NULL = Type.float.majorEncoded | 22;
-var SIMPLE_UNDEFINED = Type.float.majorEncoded | 23;
-var neg1b = BigInt(-1);
-var pos1b = BigInt(1);
-/**
-* Check if direct encoding can be used for the given options.
-* Direct encoding bypasses token creation for most values.
-* @param {EncodeOptions} options
-* @returns {boolean}
-*/
-function canDirectEncode(options) {
-	return options.addBreakTokens !== true;
-}
-/**
-* Direct encode a value to the writer, bypassing token creation for most types.
-* Falls back to token-based encoding for custom type encoders.
-* @param {ByteWriter} writer
-* @param {any} data
-* @param {EncodeOptions} options
-* @param {Reference|undefined} refStack
-*/
-function directEncode(writer, data, options, refStack) {
-	const typ = is(data);
-	const customEncoder = options.typeEncoders && options.typeEncoders[typ];
-	if (customEncoder) {
-		const tokens = customEncoder(data, typ, options, refStack);
-		if (tokens != null) {
-			tokensToEncoded(writer, tokens, cborEncoders, options);
-			return;
-		}
-	}
-	switch (typ) {
-		case "null":
-			writer.push([SIMPLE_NULL]);
-			return;
-		case "undefined":
-			writer.push([SIMPLE_UNDEFINED]);
-			return;
-		case "boolean":
-			writer.push([data ? SIMPLE_TRUE : SIMPLE_FALSE]);
-			return;
-		case "number":
-			if (!Number.isInteger(data) || !Number.isSafeInteger(data)) encodeFloat(writer, new Token(Type.float, data), options);
-			else if (data >= 0) encodeUintValue(writer, MAJOR_UINT, data);
-			else encodeUintValue(writer, MAJOR_NEGINT, data * -1 - 1);
-			return;
-		case "bigint":
-			if (data >= BigInt(0)) encodeUintValue(writer, MAJOR_UINT, data);
-			else encodeUintValue(writer, MAJOR_NEGINT, data * neg1b - pos1b);
-			return;
-		case "string": {
-			const bytes = fromString(data);
-			encodeUintValue(writer, MAJOR_STRING, bytes.length);
-			writer.push(bytes);
-			return;
-		}
-		case "Uint8Array":
-			encodeUintValue(writer, MAJOR_BYTES, data.length);
-			writer.push(data);
-			return;
-		case "Array":
-			if (!data.length) {
-				writer.push([MAJOR_ARRAY]);
-				return;
-			}
-			refStack = Ref.createCheck(refStack, data);
-			encodeUintValue(writer, MAJOR_ARRAY, data.length);
-			for (const elem of data) directEncode(writer, elem, options, refStack);
-			return;
-		case "Object":
-		case "Map":
-			tokensToEncoded(writer, typeEncoders.Object(data, typ, options, refStack), cborEncoders, options);
-			return;
-		default: {
-			const typeEncoder = typeEncoders[typ];
-			if (!typeEncoder) throw new Error(`${encodeErrPrefix} unsupported type: ${typ}`);
-			tokensToEncoded(writer, typeEncoder(data, typ, options, refStack), cborEncoders, options);
-		}
-	}
-}
-/**
-* @template {ArrayBufferLike} T
-* @overload
-* @param {any} data
-* @param {TokenTypeEncoder[]} encoders
-* @param {EncodeOptions} options
-* @param {Uint8Array<T>} destination
-* @returns {Uint8Array<T>}
-*/
-/**
-* @overload
-* @param {any} data
-* @param {TokenTypeEncoder[]} encoders
-* @param {EncodeOptions} options
-* @returns {AllocatedByteView}
-*/
-/**
-* @param {any} data
-* @param {TokenTypeEncoder[]} encoders
-* @param {EncodeOptions} options
-* @param {ByteView} [destination]
-* @returns {ByteView}
-*/
-function encodeCustom(data, encoders, options, destination) {
-	const hasDest = destination instanceof Uint8Array;
-	let writeTo = hasDest ? new U8Bl(destination) : defaultWriter;
-	const tokens = objectToTokens(data, options);
-	if (!Array.isArray(tokens) && options.quickEncodeToken) {
-		const quickBytes = options.quickEncodeToken(tokens);
-		if (quickBytes) {
-			if (hasDest) {
-				writeTo.push(quickBytes);
-				return writeTo.toBytes();
-			}
-			return quickBytes;
-		}
-		const encoder = encoders[tokens.type.major];
-		if (encoder.encodedSize) {
-			const size = encoder.encodedSize(tokens, options);
-			if (!hasDest) writeTo = new Bl(size);
-			encoder(writeTo, tokens, options);
-			if (writeTo.chunks.length !== 1) throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
-			return hasDest ? writeTo.toBytes() : asU8A(writeTo.chunks[0]);
-		}
-	}
-	writeTo.reset();
-	tokensToEncoded(writeTo, tokens, encoders, options);
-	return writeTo.toBytes(true);
-}
-/**
-* @param {any} data
-* @param {EncodeOptions} [options]
-* @returns {AllocatedByteView}
-*/
-function encode(data, options) {
-	options = Object.assign({}, defaultEncodeOptions, options);
-	if (canDirectEncode(options)) {
-		defaultWriter.reset();
-		directEncode(defaultWriter, data, options, void 0);
-		return defaultWriter.toBytes(true);
-	}
-	return encodeCustom(data, cborEncoders, options);
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@/cborg/5.1.11/e24c650a80e15c1eaf2be19ad9eb588e573106ba2ecb18c14c15852be6303448/node_modules/cborg/lib/decode.js
-/**
-* @typedef {import('./token.js').Token} Token
-* @typedef {import('../interface.js').DecodeOptions} DecodeOptions
-* @typedef {import('../interface.js').DecodeTokenizer} DecodeTokenizer
-* @typedef {import('../interface.js').TagDecodeControl} TagDecodeControl
-*/
-var defaultDecodeOptions = {
-	strict: false,
-	allowIndefinite: true,
-	allowUndefined: true,
-	allowBigInt: true
-};
-/**
-* @implements {DecodeTokenizer}
-*/
-var Tokeniser = class {
-	/**
-	* @param {Uint8Array} data
-	* @param {DecodeOptions} options
-	*/
-	constructor(data, options = {}) {
-		this._pos = 0;
-		this.data = data;
-		this.options = options;
-	}
-	pos() {
-		return this._pos;
-	}
-	done() {
-		return this._pos >= this.data.length;
-	}
-	next() {
-		const byt = this.data[this._pos];
-		let token = quick[byt];
-		if (token === void 0) {
-			const decoder = jump[byt];
-			if (!decoder) throw new Error(`${decodeErrPrefix} no decoder for major type ${byt >>> 5} (byte 0x${byt.toString(16).padStart(2, "0")})`);
-			const minor = byt & 31;
-			token = decoder(this.data, this._pos, minor, this.options);
-		}
-		this._pos += token.encodedLength;
-		return token;
-	}
-};
-var DONE = Symbol.for("DONE");
-var BREAK = Symbol.for("BREAK");
-/**
-* @param {Token} token
-* @param {DecodeTokenizer} tokeniser
-* @param {DecodeOptions} options
-* @returns {any|typeof BREAK|typeof DONE}
-*/
-function tokenToArray(token, tokeniser, options) {
-	const arr = [];
-	for (let i = 0; i < token.value; i++) {
-		const value = tokensToObject(tokeniser, options);
-		if (value === BREAK) {
-			if (token.value === Infinity) break;
-			throw new Error(`${decodeErrPrefix} got unexpected break to lengthed array`);
-		}
-		if (value === DONE) throw new Error(`${decodeErrPrefix} found array but not enough entries (got ${i}, expected ${token.value})`);
-		arr[i] = value;
-	}
-	return arr;
-}
-/**
-* @param {Token} token
-* @param {DecodeTokenizer} tokeniser
-* @param {DecodeOptions} options
-* @returns {any|typeof BREAK|typeof DONE}
-*/
-function tokenToMap(token, tokeniser, options) {
-	const useMaps = options.useMaps === true;
-	const rejectDuplicateMapKeys = options.rejectDuplicateMapKeys === true;
-	const obj = useMaps ? void 0 : {};
-	const m = useMaps ? /* @__PURE__ */ new Map() : void 0;
-	for (let i = 0; i < token.value; i++) {
-		const key = tokensToObject(tokeniser, options);
-		if (key === BREAK) {
-			if (token.value === Infinity) break;
-			throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`);
-		}
-		if (key === DONE) throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
-		if (!useMaps && typeof key !== "string") throw new Error(`${decodeErrPrefix} non-string keys not supported (got ${typeof key})`);
-		if (rejectDuplicateMapKeys) {
-			if (useMaps && m.has(key) || !useMaps && Object.hasOwn(obj, key)) throw new Error(`${decodeErrPrefix} found repeat map key "${key}"`);
-		}
-		const value = tokensToObject(tokeniser, options);
-		if (value === DONE) throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
-		if (useMaps) m.set(key, value);
-		else obj[key] = value;
-	}
-	return useMaps ? m : obj;
-}
-/**
-* Generator that yields [key, value] entries from a CBOR map token.
-* Used by tag decoders that need to preserve key types (e.g., Tag 259 Map).
-* @param {Token} token - The map token
-* @param {DecodeTokenizer} tokeniser
-* @param {DecodeOptions} options
-* @returns {Generator<[any, any], void, unknown>}
-*/
-function* tokenToMapEntries(token, tokeniser, options) {
-	for (let i = 0; i < token.value; i++) {
-		const key = tokensToObject(tokeniser, options);
-		if (key === BREAK) {
-			if (token.value === Infinity) break;
-			throw new Error(`${decodeErrPrefix} got unexpected break to lengthed map`);
-		}
-		if (key === DONE) throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no key], expected ${token.value})`);
-		const value = tokensToObject(tokeniser, options);
-		if (value === DONE) throw new Error(`${decodeErrPrefix} found map but not enough entries (got ${i} [no value], expected ${token.value})`);
-		yield [key, value];
-	}
-}
-/**
-* Creates a TagDecodeControl object for tag decoders.
-* @param {DecodeTokenizer} tokeniser
-* @param {DecodeOptions} options
-* @returns {TagDecodeControl}
-*/
-function createTagDecodeControl(tokeniser, options) {
-	let called = false;
-	/**
-	* @type {TagDecodeControl}
-	*/
-	const decode = function() {
-		if (called) throw new Error(`${decodeErrPrefix} tag decode() may only be called once`);
-		called = true;
-		const value = tokensToObject(tokeniser, options);
-		if (value === DONE) throw new Error(`${decodeErrPrefix} tag content missing`);
-		if (value === BREAK) throw new Error(`${decodeErrPrefix} got unexpected break in tag content`);
-		return value;
-	};
-	decode.entries = function() {
-		if (called) throw new Error(`${decodeErrPrefix} tag decode() may only be called once`);
-		called = true;
-		const token = tokeniser.next();
-		if (!Type.equals(token.type, Type.map)) throw new Error(`${decodeErrPrefix} entries() requires map content, got ${token.type.name}`);
-		const entries = [];
-		for (const entry of tokenToMapEntries(token, tokeniser, options)) entries.push(entry);
-		return entries;
-	};
-	Object.defineProperty(decode, "_called", {
-		get() {
-			return called;
-		},
-		enumerable: false
-	});
-	return decode;
-}
-/**
-* @param {DecodeTokenizer} tokeniser
-* @param {DecodeOptions} options
-* @returns {any|typeof BREAK|typeof DONE}
-*/
-function tokensToObject(tokeniser, options) {
-	if (tokeniser.done()) return DONE;
-	const token = tokeniser.next();
-	if (Type.equals(token.type, Type.break)) return BREAK;
-	if (token.type.terminal) return token.value;
-	if (Type.equals(token.type, Type.array)) return tokenToArray(token, tokeniser, options);
-	if (Type.equals(token.type, Type.map)) return tokenToMap(token, tokeniser, options);
-	if (Type.equals(token.type, Type.tag)) {
-		if (options.tags && typeof options.tags[token.value] === "function") {
-			const decodeControl = createTagDecodeControl(tokeniser, options);
-			const result = options.tags[token.value](decodeControl);
-			if (!decodeControl._called) throw new Error(`${decodeErrPrefix} tag decoder must call decode() or entries()`);
-			return result;
-		}
-		throw new Error(`${decodeErrPrefix} tag not supported (${token.value})`);
-	}
-	throw new Error("unsupported");
-}
-/**
-* @param {Uint8Array} data
-* @param {DecodeOptions} [options]
-* @returns {[any, Uint8Array]}
-*/
-function decodeFirst(data, options) {
-	if (!(data instanceof Uint8Array)) throw new Error(`${decodeErrPrefix} data to decode must be a Uint8Array`);
-	options = Object.assign({}, defaultDecodeOptions, options);
-	const u8aData = asU8A(data);
-	const tokeniser = options.tokenizer || new Tokeniser(u8aData, options);
-	const decoded = tokensToObject(tokeniser, options);
-	if (decoded === DONE) throw new Error(`${decodeErrPrefix} did not find any content to decode`);
-	if (decoded === BREAK) throw new Error(`${decodeErrPrefix} got unexpected break`);
-	return [decoded, data.subarray(tokeniser.pos())];
-}
-/**
-* @param {Uint8Array} data
-* @param {DecodeOptions} [options]
-* @returns {any}
-*/
-function decode(data, options) {
-	const [decoded, remainder] = decodeFirst(data, options);
-	if (remainder.length > 0) throw new Error(`${decodeErrPrefix} too many terminals, data makes no sense`);
-	return decoded;
-}
-Object.defineProperty(class Tagged {
-	/**
-	* @param {number} tag - CBOR tag number, a non-negative integer
-	* @param {any} value - The value to be tagged; encoded recursively
-	*/
-	constructor(tag, value) {
-		if (typeof tag !== "number" || !Number.isInteger(tag) || tag < 0) throw new TypeError("Tagged: tag must be a non-negative integer");
-		this.tag = tag;
-		this.value = value;
-	}
-	/**
-	* Build a tag decoder for use in `decode()`'s `tags` option that returns the
-	* decoded content wrapped in a `Tagged` instance, preserving the tag number
-	* for the caller to inspect.
-	*
-	* @param {number} tag - The CBOR tag number this decoder will be registered for
-	* @returns {TaggedTagDecoder}
-	*
-	* @example
-	* import { decode, Tagged } from 'cborg'
-	* const value = decode(bytes, { tags: { 16: Tagged.decoder(16) } })
-	* // value instanceof Tagged; value.tag === 16
-	*/
-	static decoder(tag) {
-		return (decode) => new Tagged(tag, decode());
-	}
-	/**
-	* Build a `tags` option for `decode()` that wraps each listed tag number in
-	* a `Tagged` instance, preserving those tags through decode without
-	* registering a dedicated decoder per tag.
-	*
-	* @param {...number} tagNumbers - One or more CBOR tag numbers to preserve
-	* @returns {{[tagNumber: number]: TaggedTagDecoder}}
-	*
-	* @example
-	* import { decode, Tagged } from 'cborg'
-	* const value = decode(bytes, { tags: Tagged.preserve(16, 96) })
-	*/
-	static preserve(...tagNumbers) {
-		/** @type {{[tagNumber: number]: TaggedTagDecoder}} */
-		const tags = {};
-		for (const tag of tagNumbers) tags[tag] = Tagged.decoder(tag);
-		return tags;
-	}
-}.prototype, Symbol.toStringTag, { value: "Tagged" });
-Uint8Array.prototype.toBase64;
-Uint8Array.fromBase64;
-function decodeCBOR(data) {
-	return decode(data, {
-		useMaps: true,
-		rejectDuplicateMapKeys: true
-	});
-}
-function encodeCBOR(data) {
-	return encode(data, rfc8949EncodeOptions);
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@ldclabs/cose-ts/1.7.0/a470182239a6259287f50f513c384f2f3f3a1550025b6307427708908f279082/node_modules/@ldclabs/cose-ts/dist/map.js
-function assertText(value, name) {
-	if (typeof value === "string") return value;
-	throw new TypeError(`${name} must be a string, but got ${String(value)}`);
-}
-function assertInt(value, name) {
-	if (Number.isSafeInteger(value)) return value;
-	throw new TypeError(`${name} must be a integer, but got ${String(value)}`);
-}
-function assertIntOrText(value, name) {
-	if (typeof value === "string") return value;
-	if (Number.isSafeInteger(value)) return value;
-	throw new TypeError(`${name} must be a integer or string, but got ${String(value)}`);
-}
-function assertBytes(value, name) {
-	if (value instanceof Uint8Array) return value;
-	throw new TypeError(`${name} must be a Uint8Array, but got ${String(value)}`);
-}
-function assertBool(value, name) {
-	if (typeof value === "boolean") return value;
-	throw new TypeError(`${name} must be a Boolean, but got ${String(value)}`);
-}
-function assertMap(value, name) {
-	if (value instanceof Map) return value;
-	throw new TypeError(`${name} must be a Map, but got ${String(value)}`);
-}
-var KVMap = class KVMap {
-	_raw;
-	static fromBytes(data) {
-		return new KVMap(decodeCBOR(data));
-	}
-	constructor(kv = /* @__PURE__ */ new Map()) {
-		if (!(kv instanceof Map)) throw new TypeError("key/value must be a Map");
-		this._raw = kv;
-	}
-	has(key) {
-		return this._raw.has(key);
-	}
-	delete(key) {
-		return this._raw.delete(key);
-	}
-	getInt(key, name) {
-		return assertInt(this._raw.get(key), name ?? String(key));
-	}
-	getText(key, name) {
-		return assertText(this._raw.get(key), name ?? String(key));
-	}
-	getBytes(key, name) {
-		return assertBytes(this._raw.get(key), name ?? String(key));
-	}
-	getBool(key, name) {
-		return assertBool(this._raw.get(key), name ?? String(key));
-	}
-	getType(key, assertFn, name) {
-		return assertFn(this._raw.get(key), name ?? String(key));
-	}
-	getArray(key, assertFn, name) {
-		const na = name ? name : String(key);
-		const arr = this._raw.get(key);
-		if (!Array.isArray(arr)) throw new TypeError(`${na} must be an array, but got ${String(arr)}`);
-		for (const item of arr) assertFn(item, na);
-		return arr;
-	}
-	getParam(key) {
-		return this._raw.get(key);
-	}
-	setParam(key, value) {
-		this._raw.set(key, value);
-		return this;
-	}
-	getCBORParam(key) {
-		return this._raw.has(key) ? decodeCBOR(assertBytes(this._raw.get(key), String(key))) : void 0;
-	}
-	setCBORParam(key, value) {
-		this._raw.set(key, encodeCBOR(value));
-		return this;
-	}
-	clone() {
-		return new Map(this._raw);
-	}
-	toRaw() {
-		return this._raw;
-	}
-	toBytes() {
-		return encodeCBOR(this._raw);
-	}
-};
-new Uint8Array([208]);
-new Uint8Array([209]);
-var Sign1MessagePrefix = new Uint8Array([210]);
-var CwtPrefix = new Uint8Array([216, 61]);
-new Uint8Array([216, 96]);
-new Uint8Array([216, 97]);
-new Uint8Array([216, 98]);
-var CBORSelfPrefix = new Uint8Array([
-	217,
-	217,
-	247
-]);
-function withTag(tag, data) {
-	return concatBytes(tag, data);
-}
-function skipTag(tag, data) {
-	if (data.length < tag.length) return data;
-	for (let i = 0; i < tag.length; i++) if (data[i] !== tag[i]) return data;
-	return data.subarray(tag.length);
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@ldclabs/cose-ts/1.7.0/a470182239a6259287f50f513c384f2f3f3a1550025b6307427708908f279082/node_modules/@ldclabs/cose-ts/dist/cwt.js
-/**
-* Claims represents a set of common claims for CWT.
-*
-* Encode claims as the payload of a COSE message, commonly COSE_Sign1, then
-* apply withCWTTag() when the surrounding protocol expects the CWT tag.
-*
-* @example
-* ```ts
-* const claims = new Claims()
-* claims.iss = 'issuer'
-* claims.aud = 'service'
-* claims.exp = Math.floor(Date.now() / 1000) + 3600
-* const token = withCWTTag(new Sign1Message(claims.toBytes()).toBytes(key))
-* ```
-*
-* Reference https://www.iana.org/assignments/cwt/cwt.xhtml
-*/
-var Claims = class Claims extends KVMap {
-	static fromBytes(data) {
-		return new Claims(decodeCBOR(data));
-	}
-	constructor(kv = /* @__PURE__ */ new Map()) {
-		super(kv);
-	}
-	get iss() {
-		return this.getText(1, "iss");
-	}
-	set iss(iss) {
-		this.setParam(1, assertText(iss, "iss"));
-	}
-	get sub() {
-		return this.getText(2, "sub");
-	}
-	set sub(sub) {
-		this.setParam(2, assertText(sub, "sub"));
-	}
-	get aud() {
-		return this.getText(3, "aud");
-	}
-	set aud(aud) {
-		this.setParam(3, assertText(aud, "aud"));
-	}
-	get exp() {
-		return this.getInt(4, "exp");
-	}
-	set exp(exp) {
-		this.setParam(4, assertInt(exp, "exp"));
-	}
-	get nbf() {
-		return this.getInt(5, "nbf");
-	}
-	set nbf(nbf) {
-		this.setParam(5, assertInt(nbf, "nbf"));
-	}
-	get iat() {
-		return this.getInt(6, "iat");
-	}
-	set iat(iat) {
-		this.setParam(6, assertInt(iat, "iat"));
-	}
-	get cti() {
-		return this.getBytes(7, "cti");
-	}
-	set cti(cti) {
-		this.setParam(7, assertBytes(cti, "cti"));
-	}
-	get cnf() {
-		return this.getType(8, assertMap, "cnf");
-	}
-	set cnf(cnf) {
-		this.setParam(8, assertMap(cnf, "cnf"));
-	}
-	get scope() {
-		return this.getText(9, "scope");
-	}
-	set scope(scope) {
-		this.setParam(9, assertText(scope, "scope"));
-	}
-	get nonce() {
-		return this.getBytes(10, "nonce");
-	}
-	set nonce(nonce) {
-		this.setParam(10, assertBytes(nonce, "nonce"));
-	}
-};
-function withCWTTag(coseData) {
-	return withTag(CwtPrefix, coseData);
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@noble/curves/2.4.0/766129a921e8dfd2ef1de557b88b41133e3334d958e354fac1f5d17f98661627/node_modules/@noble/curves/abstract/edwards.js
-/**
-* Twisted Edwards curve. The formula is: ax² + y² = 1 + dx²y².
-* For design rationale of types / exports, see weierstrass module documentation.
-* Untwisted Edwards curves exist, but they aren't used in real-world protocols.
-* @module
-*/
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-var _0n = /* @__PURE__ */ BigInt(0);
-var _1n$1 = /* @__PURE__ */ BigInt(1);
-var _2n$1 = /* @__PURE__ */ BigInt(2);
-var _4n = /* @__PURE__ */ BigInt(4);
-var _8n$1 = /* @__PURE__ */ BigInt(8);
-function isEdValidXY(Fp, CURVE, x, y) {
-	const x2 = Fp.sqr(x);
-	const y2 = Fp.sqr(y);
-	const left = Fp.add(Fp.mul(CURVE.a, x2), y2);
-	const right = Fp.add(Fp.ONE, Fp.mul(CURVE.d, Fp.mul(x2, y2)));
-	return Fp.eql(left, right);
-}
-/**
-* @param params - Curve parameters. See {@link EdwardsOpts}.
-* @param extraOpts - Optional helpers and overrides. See {@link EdwardsExtraOpts}.
-* @returns Edwards point constructor. Generator validation here only checks
-*   that `(Gx, Gy)` satisfies the affine Edwards equation.
-*   RFC 8032 base-point constraints like `B != (0,1)` and `[L]B = 0`
-*   are left to the caller's chosen parameters, since eager subgroup
-*   validation here adds about 10-15ms to heavyweight imports like ed448.
-*   The returned constructor also eagerly marks `Point.BASE` for W=6
-*   precompute caching. Some code paths still assume
-*   `Fp.BYTES === Fn.BYTES`, so mismatched byte lengths are not fully audited here.
-* @throws If the curve parameters or Edwards overrides are invalid. {@link Error}
-* @example
-* ```ts
-* import { edwards } from '@noble/curves/abstract/edwards.js';
-* import { jubjub } from '@noble/curves/misc.js';
-* // Build a point constructor from explicit curve parameters, then use its base point.
-* const Point = edwards(jubjub.Point.CURVE());
-* Point.BASE.toHex();
-* ```
-*/
-function edwards(params, extraOpts = {}) {
-	validateObject(extraOpts, {}, {}, "extraOpts");
-	const opts = extraOpts;
-	const validated = createCurveFields("edwards", params, opts, opts.FpFnLE);
-	const { Fp, Fn } = validated;
-	let CURVE = validated.CURVE;
-	const { h: cofactor } = CURVE;
-	if (FpLegendre(Fp, CURVE.a) !== 1) throw new Error("edwards: CURVE.a must be a square in Fp for complete addition formulas");
-	if (FpLegendre(Fp, CURVE.d) !== -1) throw new Error("edwards: CURVE.d must be a non-square in Fp for complete addition formulas");
-	validateObject(opts, {}, {
-		uvRatio: "function",
-		randomBytes: "function"
-	});
-	const randomBytes$2 = opts.randomBytes === void 0 ? randomBytes : opts.randomBytes;
-	const MASK = _2n$1 << BigInt(Fp.BYTES * 8) - _1n$1;
-	function isOdd(n) {
-		if (!Fp.isOdd) throw new Error("Field does not have .isOdd()");
-		return Fp.isOdd(n);
-	}
-	const uvRatio = opts.uvRatio === void 0 ? (u, v) => {
-		try {
-			return {
-				isValid: true,
-				value: Fp.sqrt(Fp.div(u, v))
-			};
-		} catch (e) {
-			return {
-				isValid: false,
-				value: _0n
-			};
-		}
-	} : opts.uvRatio;
-	if (!isEdValidXY(Fp, CURVE, CURVE.Gx, CURVE.Gy)) throw new Error("bad curve params: generator point");
-	const mulA = Fp.eql(CURVE.a, Fp.neg(Fp.ONE)) ? (x) => Fp.neg(x) : Fp.eql(CURVE.a, Fp.ONE) ? (x) => x : (x) => Fp.mul(CURVE.a, x);
-	/**
-	* Asserts coordinate is valid: 0 <= n < MASK.
-	* Coordinates >= Fp.ORDER are allowed for zip215.
-	*/
-	function acoord(title, n, banZero = false) {
-		const min = banZero ? _1n$1 : _0n;
-		aInRange("coordinate " + title, n, min, MASK);
-		return n;
-	}
-	function aedpoint(other) {
-		if (!(other instanceof Point)) throw new Error("EdwardsPoint expected");
-	}
-	class Point {
-		static BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE, Fp.mul(CURVE.Gx, CURVE.Gy));
-		static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ONE, Fp.ZERO);
-		static Fp = Fp;
-		static Fn = Fn;
-		X;
-		Y;
-		Z;
-		T;
-		constructor(X, Y, Z, T) {
-			this.X = acoord("x", X);
-			this.Y = acoord("y", Y);
-			this.Z = acoord("z", Z, true);
-			this.T = acoord("t", T);
-			Object.freeze(this);
-		}
-		static CURVE() {
-			return CURVE;
-		}
-		/**
-		* Create one extended Edwards point from affine coordinates.
-		* Does NOT validate that the point is on-curve or torsion-free.
-		* Use `.assertValidity()` on adversarial inputs.
-		*/
-		static fromAffine(p) {
-			if (p instanceof Point) throw new Error("extended point not allowed");
-			const { x, y } = p || {};
-			acoord("x", x);
-			acoord("y", y);
-			return new Point(x, y, Fp.ONE, Fp.mul(x, y));
-		}
-		static fromBytes(bytes, zip215 = false) {
-			const len = Fp.BYTES;
-			const { a, d } = CURVE;
-			bytes = copyBytes(abytes(bytes, len, "point"));
-			abool(zip215, "zip215");
-			const normed = copyBytes(bytes);
-			const lastByte = bytes[len - 1];
-			normed[len - 1] = lastByte & -129;
-			const y = bytesToNumberLE(normed);
-			const max = zip215 ? MASK : Fp.ORDER;
-			aInRange("point.y", y, _0n, max);
-			const y2 = Fp.sqr(y);
-			const u = Fp.sub(y2, Fp.ONE);
-			const v = Fp.sub(Fp.mulN(d, y2), a);
-			let { isValid, value: x } = uvRatio(u, v);
-			if (!isValid) throw new Error("bad point: invalid y coordinate");
-			const isXOdd = isOdd(x);
-			const isLastByteOdd = (lastByte & 128) !== 0;
-			if (!zip215 && Fp.is0(x) && isLastByteOdd) throw new Error("bad point: x=0 and x_0=1");
-			if (isLastByteOdd !== isXOdd) x = Fp.neg(x);
-			return Point.fromAffine({
-				x,
-				y
-			});
-		}
-		static fromHex(hex, zip215 = false) {
-			return Point.fromBytes(hexToBytes(hex), zip215);
-		}
-		get x() {
-			return this.toAffine().x;
-		}
-		get y() {
-			return this.toAffine().y;
-		}
-		precompute(windowSize = 6, isLazy = true) {
-			wnaf.setWindowSize(this, windowSize);
-			if (!isLazy) this.multiply(_2n$1);
-			return this;
-		}
-		assertValidity() {
-			const p = this;
-			const { a, d } = CURVE;
-			if (p.is0()) throw new Error("bad point: ZERO");
-			const { X, Y, Z, T } = p;
-			const X2 = Fp.sqr(X);
-			const Y2 = Fp.sqr(Y);
-			const Z2 = Fp.sqr(Z);
-			const Z4 = Fp.sqr(Z2);
-			const aX2 = Fp.mul(X2, a);
-			const left = Fp.mul(Fp.add(aX2, Y2), Z2);
-			const right = Fp.add(Z4, Fp.mul(d, Fp.mul(X2, Y2)));
-			if (!Fp.eql(left, right)) throw new Error("bad point: equation left != right (1)");
-			const XY = Fp.mul(X, Y);
-			const ZT = Fp.mul(Z, T);
-			if (!Fp.eql(XY, ZT)) throw new Error("bad point: equation left != right (2)");
-		}
-		equals(other) {
-			aedpoint(other);
-			const { X: X1, Y: Y1, Z: Z1 } = this;
-			const { X: X2, Y: Y2, Z: Z2 } = other;
-			const X1Z2 = Fp.mul(X1, Z2);
-			const X2Z1 = Fp.mul(X2, Z1);
-			const Y1Z2 = Fp.mul(Y1, Z2);
-			const Y2Z1 = Fp.mul(Y2, Z1);
-			return Fp.eql(X1Z2, X2Z1) && Fp.eql(Y1Z2, Y2Z1);
-		}
-		is0() {
-			return this.equals(Point.ZERO);
-		}
-		negate() {
-			return new Point(Fp.neg(this.X), this.Y, this.Z, Fp.neg(this.T));
-		}
-		double() {
-			const { X: X1, Y: Y1, Z: Z1 } = this;
-			const A = Fp.sqr(X1);
-			const B = Fp.sqr(Y1);
-			const C = Fp.mul(Fp.sqr(Z1), _2n$1);
-			const D = mulA(A);
-			const x1y1 = Fp.addN(X1, Y1);
-			const E = Fp.sub(Fp.subN(Fp.sqr(x1y1), A), B);
-			const G = Fp.addN(D, B);
-			const F = Fp.subN(G, C);
-			const H = Fp.subN(D, B);
-			const X3 = Fp.mul(E, F);
-			const Y3 = Fp.mul(G, H);
-			const T3 = Fp.mul(E, H);
-			const Z3 = Fp.mul(F, G);
-			return new Point(X3, Y3, Z3, T3);
-		}
-		add(other) {
-			aedpoint(other);
-			const { d } = CURVE;
-			const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
-			const { X: X2, Y: Y2, Z: Z2, T: T2 } = other;
-			const A = Fp.mul(X1, X2);
-			const B = Fp.mul(Y1, Y2);
-			const C = Fp.mul(Fp.mulN(T1, d), T2);
-			const D = Fp.mul(Z1, Z2);
-			const E = Fp.sub(Fp.subN(Fp.mulN(Fp.addN(X1, Y1), Fp.addN(X2, Y2)), A), B);
-			const F = Fp.subN(D, C);
-			const G = Fp.addN(D, C);
-			const H = Fp.sub(B, mulA(A));
-			const X3 = Fp.mul(E, F);
-			const Y3 = Fp.mul(G, H);
-			const T3 = Fp.mul(E, H);
-			const Z3 = Fp.mul(F, G);
-			return new Point(X3, Y3, Z3, T3);
-		}
-		subtract(other) {
-			aedpoint(other);
-			return this.add(other.negate());
-		}
-		multiply(scalar) {
-			if (!Fn.isValidNot0(scalar)) throw new RangeError("invalid scalar: expected 1 <= sc < curve.n");
-			const { p, f } = wnaf.mulSecret(this, scalar, cofactor, normalize);
-			return normalize([p, f])[0];
-		}
-		multiplyUnsafe(scalar) {
-			if (!Fn.isValid(scalar)) throw new RangeError("invalid scalar: expected 0 <= sc < curve.n");
-			if (scalar === _0n) return Point.ZERO;
-			if (this.is0() || scalar === _1n$1) return this;
-			return wnaf.mulUnsafe(this, scalar, normalize);
-		}
-		isSmallOrder() {
-			return this.clearCofactor().is0();
-		}
-		isTorsionFree() {
-			return wnaf.mulUnsafe(this, CURVE.n).is0();
-		}
-		toAffine(invertedZ) {
-			const p = this;
-			let iz = invertedZ;
-			if (iz != null && typeof iz !== "bigint") throw new TypeError("\"invertedZ\" expected bigint, got type=" + typeof iz);
-			const { X, Y, Z } = p;
-			const is0 = p.is0();
-			if (iz == null) iz = is0 ? Fp.create(_8n$1) : Fp.inv(Z);
-			const x = Fp.mul(X, iz);
-			const y = Fp.mul(Y, iz);
-			const zz = Fp.mul(Z, iz);
-			if (is0) return {
-				x: Fp.ZERO,
-				y: Fp.ONE
-			};
-			if (!Fp.eql(zz, Fp.ONE)) throw new Error("invZ was invalid");
-			return {
-				x,
-				y
-			};
-		}
-		clearCofactor() {
-			if (cofactor === _1n$1) return this;
-			if (cofactor === _2n$1) return this.double();
-			if (cofactor === _4n) return this.double().double();
-			if (cofactor === _8n$1) return this.double().double().double();
-			return this.multiplyUnsafe(cofactor);
-		}
-		toBytes() {
-			const { x, y } = this.toAffine();
-			const bytes = Fp.toBytes(y);
-			bytes[bytes.length - 1] |= isOdd(x) ? 128 : 0;
-			return bytes;
-		}
-		toHex() {
-			return bytesToHex(this.toBytes());
-		}
-		toString() {
-			return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
-		}
-	}
-	const normalize = (points) => normalizeZ(Point, points);
-	const wnaf = new ScalarMultiplier(Point, randomBytes$2);
-	if (wnaf.bits >= 6) Point.BASE.precompute(6);
-	Object.freeze(Point.prototype);
-	Object.freeze(Point);
-	return Point;
-}
-/**
-* Initializes EdDSA signatures over given Edwards curve.
-* @param Point - Edwards point constructor.
-* @param cHash - Hash function.
-* @param eddsaOpts - Optional signature helpers. See {@link EdDSAOpts}.
-* @returns EdDSA helper namespace.
-* @throws If the hash function, options, or derived point operations are invalid. {@link Error}
-* @example
-* Initializes EdDSA signatures over given Edwards curve.
-*
-* ```ts
-* import { eddsa } from '@noble/curves/abstract/edwards.js';
-* import { jubjub } from '@noble/curves/misc.js';
-* import { sha512 } from '@noble/hashes/sha2.js';
-* const sigs = eddsa(jubjub.Point, sha512);
-* const { secretKey, publicKey } = sigs.keygen();
-* const msg = new TextEncoder().encode('hello noble');
-* const sig = sigs.sign(msg, secretKey);
-* const isValid = sigs.verify(sig, msg, publicKey);
-* ```
-*/
-function eddsa(Point, cHash, eddsaOpts = {}) {
-	validatePointCons(Point);
-	if (typeof cHash !== "function") throw new Error("\"hash\" function param is required");
-	const hash = cHash;
-	const opts = eddsaOpts;
-	validateObject(opts, {}, {
-		adjustScalarBytes: "function",
-		randomBytes: "function",
-		domain: "function",
-		prehash: "function",
-		zip215: "boolean",
-		mapToCurve: "function",
-		toMontgomery: "function",
-		toMontgomerySecret: "function"
-	});
-	const { prehash } = opts;
-	const { BASE, Fp, Fn } = Point;
-	const outputLen = hash.outputLen;
-	const expectedLen = 2 * Fp.BYTES;
-	if (outputLen !== void 0) {
-		asafenumber(outputLen, "hash.outputLen");
-		if (outputLen !== expectedLen) throw new Error(`hash.outputLen must be ${expectedLen}, got ${outputLen}`);
-	}
-	const randomBytes$3 = opts.randomBytes === void 0 ? randomBytes : opts.randomBytes;
-	const toMontgomery = opts.toMontgomery;
-	const toMontgomerySecret = opts.toMontgomerySecret;
-	const adjustScalarBytes = opts.adjustScalarBytes === void 0 ? (bytes) => bytes : opts.adjustScalarBytes;
-	const domain = opts.domain === void 0 ? (data, ctx, phflag) => {
-		abool(phflag, "phflag");
-		if (ctx.length || phflag) throw new Error("Contexts/pre-hash are not supported");
-		return data;
-	} : opts.domain;
-	function modN_LE(hash) {
-		return Fn.create(bytesToNumberLE(hash));
-	}
-	function getPrivateScalar(key) {
-		const len = lengths.secretKey;
-		abytes(key, lengths.secretKey, "secretKey");
-		const hashed = abytes(hash(key), 2 * len, "hashedSecretKey");
-		const head = adjustScalarBytes(hashed.slice(0, len));
-		return {
-			head,
-			prefix: hashed.slice(len, 2 * len),
-			scalar: modN_LE(head)
-		};
-	}
-	/** Convenience method that creates public key from scalar. RFC8032 5.1.5
-	* Also exposes the derived scalar/prefix tuple and point form reused by sign().
-	*/
-	function getExtendedPublicKey(secretKey) {
-		const { head, prefix, scalar } = getPrivateScalar(secretKey);
-		const point = BASE.multiply(scalar);
-		return {
-			head,
-			prefix,
-			scalar,
-			point,
-			pointBytes: point.toBytes()
-		};
-	}
-	/** Calculates EdDSA pub key. RFC8032 5.1.5. */
-	function getPublicKey(secretKey) {
-		return getExtendedPublicKey(secretKey).pointBytes;
-	}
-	function hashDomainToScalar(context = Uint8Array.of(), ...msgs) {
-		const msg = concatBytes$1(...msgs);
-		return modN_LE(hash(domain(msg, abytes(context, void 0, "context"), !!prehash)));
-	}
-	/** Signs message with secret key. RFC8032 5.1.6 */
-	function sign(msg, secretKey, options = {}) {
-		validateObject(options, {}, {}, "options");
-		msg = copyBytes(abytes(msg, void 0, "message"));
-		if (prehash) msg = prehash(msg);
-		const { prefix, scalar, pointBytes } = getExtendedPublicKey(secretKey);
-		const r = hashDomainToScalar(options.context, prefix, msg);
-		const R = BASE.multiply(r).toBytes();
-		const k = hashDomainToScalar(options.context, R, pointBytes, msg);
-		const s = Fn.create(r + k * scalar);
-		if (!Fn.isValid(s)) throw new Error("sign failed: invalid s");
-		const rs = concatBytes$1(R, Fn.toBytes(s));
-		return abytes(rs, lengths.signature, "result");
-	}
-	const verifyOpts = { zip215: opts.zip215 };
-	/**
-	* Verifies EdDSA signature against message and public key. RFC 8032 §§5.1.7 and 5.2.7.
-	* A cofactored verification equation is checked.
-	*/
-	function verify(sig, msg, publicKey, options = verifyOpts) {
-		validateObject(options);
-		const { context } = options;
-		const zip215 = options.zip215 === void 0 ? !!verifyOpts.zip215 : options.zip215;
-		const len = lengths.signature;
-		sig = abytes(sig, len, "signature");
-		msg = abytes(msg, void 0, "message");
-		publicKey = abytes(publicKey, lengths.publicKey, "publicKey");
-		if (zip215 !== void 0) abool(zip215, "zip215");
-		if (prehash) msg = prehash(msg);
-		const mid = len / 2;
-		const r = sig.subarray(0, mid);
-		const s = bytesToNumberLE(sig.subarray(mid, len));
-		let A, R, SB;
-		try {
-			A = Point.fromBytes(publicKey, zip215);
-			R = Point.fromBytes(r, zip215);
-			SB = BASE.multiplyUnsafe(s);
-		} catch (error) {
-			return false;
-		}
-		if (!zip215 && A.isSmallOrder()) return false;
-		const k = hashDomainToScalar(context, r, publicKey, msg);
-		return R.add(A.multiplyUnsafe(k)).subtract(SB).clearCofactor().is0();
-	}
-	const _size = Fp.BYTES;
-	const lengths = {
-		secretKey: _size,
-		publicKey: _size,
-		signature: 2 * _size,
-		seed: _size
-	};
-	function randomSecretKey(seed) {
-		seed = seed === void 0 ? randomBytes$3(lengths.seed) : seed;
-		return abytes(seed, lengths.seed, "seed");
-	}
-	function isValidSecretKey(key) {
-		return isBytes(key) && key.length === lengths.secretKey;
-	}
-	function isValidPublicKey(key, zip215) {
-		try {
-			return !!Point.fromBytes(key, zip215 === void 0 ? verifyOpts.zip215 : zip215);
-		} catch (error) {
-			return false;
-		}
-	}
-	const utils = {
-		getExtendedPublicKey,
-		randomSecretKey,
-		isValidSecretKey,
-		isValidPublicKey,
-		/** Converts an Edwards public key to a companion Montgomery public key. */
-		toMontgomery(publicKey) {
-			if (toMontgomery === void 0) throw new Error("Montgomery conversion is not supported for this curve");
-			return toMontgomery(Point.fromBytes(publicKey));
-		},
-		toMontgomerySecret(secretKey) {
-			if (toMontgomerySecret === void 0) throw new Error("Montgomery conversion is not supported for this curve");
-			return toMontgomerySecret(secretKey);
-		}
-	};
-	Object.freeze(lengths);
-	Object.freeze(utils);
-	return Object.freeze({
-		keygen: createKeygen(randomSecretKey, getPublicKey),
-		getPublicKey,
-		sign,
-		verify,
-		utils,
-		Point,
-		lengths
-	});
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@noble/curves/2.4.0/766129a921e8dfd2ef1de557b88b41133e3334d958e354fac1f5d17f98661627/node_modules/@noble/curves/ed25519.js
-/**
-* ed25519 Twisted Edwards curve with following addons:
-* - X25519 ECDH
-* - Ristretto cofactor elimination
-* - Elligator hash-to-group / point indistinguishability
-* @module
-*/
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-var _1n = /* @__PURE__ */ BigInt(1);
-var _2n = /* @__PURE__ */ BigInt(2);
-var _5n = /* @__PURE__ */ BigInt(5);
-var _8n = /* @__PURE__ */ BigInt(8);
-var ed25519_CURVE_p = /* @__PURE__ */ BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed");
-var ed25519_CURVE = /* @__PURE__ */ (() => ({
-	p: ed25519_CURVE_p,
-	n: BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed"),
-	h: _8n,
-	a: BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec"),
-	d: BigInt("0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3"),
-	Gx: BigInt("0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a"),
-	Gy: BigInt("0x6666666666666666666666666666666666666666666666666666666666666658")
-}))();
-function ed25519_pow_2_252_3(x) {
-	const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
-	const P = ed25519_CURVE_p;
-	const b2 = x * x % P * x % P;
-	const b4 = pow2(b2, _2n, P) * b2 % P;
-	const b5 = pow2(b4, _1n, P) * x % P;
-	const b10 = pow2(b5, _5n, P) * b5 % P;
-	const b20 = pow2(b10, _10n, P) * b10 % P;
-	const b40 = pow2(b20, _20n, P) * b20 % P;
-	const b80 = pow2(b40, _40n, P) * b40 % P;
-	const b160 = pow2(b80, _80n, P) * b80 % P;
-	const b240 = pow2(b160, _80n, P) * b80 % P;
-	const b250 = pow2(b240, _10n, P) * b10 % P;
-	return {
-		pow_p_5_8: pow2(b250, _2n, P) * x % P,
-		b2
-	};
-}
-function adjustScalarBytes(bytes) {
-	bytes[0] &= 248;
-	bytes[31] &= 127;
-	bytes[31] |= 64;
-	return bytes;
-}
-var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
-function uvRatio(u, v) {
-	const P = ed25519_CURVE_p;
-	const v3 = mod(v * v * v, P);
-	const pow = ed25519_pow_2_252_3(u * mod(v3 * v3 * v, P)).pow_p_5_8;
-	let x = mod(u * v3 * pow, P);
-	const vx2 = mod(v * x * x, P);
-	const root1 = x;
-	const root2 = mod(x * ED25519_SQRT_M1, P);
-	const useRoot1 = vx2 === u;
-	const useRoot2 = vx2 === mod(-u, P);
-	const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P);
-	if (useRoot1) x = root1;
-	if (useRoot2 || noRoot) x = root2;
-	if (isNegativeLE(x, P)) x = mod(-x, P);
-	return {
-		isValid: useRoot1 || useRoot2,
-		value: x
-	};
-}
-var ed25519_Point = /* @__PURE__ */ edwards(ed25519_CURVE, { uvRatio });
-var Fp = /* @__PURE__ */ (() => ed25519_Point.Fp)();
-function toMontgomery(point) {
-	const { y } = point;
-	return Fp.toBytes(Fp.div(_1n + y, _1n - y));
-}
-function toMontgomerySecret(secretKey) {
-	const size = ed25519_Point.Fp.BYTES;
-	abytes$1(secretKey, size);
-	return adjustScalarBytes(sha512(secretKey.subarray(0, size))).subarray(0, size);
-}
-function ed(opts) {
-	return eddsa(ed25519_Point, sha512, Object.assign({
-		adjustScalarBytes,
-		toMontgomery,
-		toMontgomerySecret,
-		zip215: true
-	}, opts));
-}
-/**
-* ed25519 curve with EdDSA signatures.
-* Seeded `keygen(seed)` / `utils.randomSecretKey(seed)` reuse the provided
-* 32-byte seed buffer instead of copying it.
-* @example
-* Generate one Ed25519 keypair, sign a message, and verify it.
-*
-* ```js
-* import { ed25519 } from '@noble/curves/ed25519.js';
-* const { secretKey, publicKey } = ed25519.keygen();
-* // const publicKey = ed25519.getPublicKey(secretKey);
-* const msg = new TextEncoder().encode('hello noble');
-* const sig = ed25519.sign(msg, secretKey);
-* const isValid = ed25519.verify(sig, msg, publicKey); // ZIP215
-* // RFC8032 / FIPS 186-5
-* const isValid2 = ed25519.verify(sig, msg, publicKey, { zip215: false });
-* ```
-*/
-var ed25519 = /* @__PURE__ */ ed({});
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@ldclabs/cose-ts/1.7.0/a470182239a6259287f50f513c384f2f3f3a1550025b6307427708908f279082/node_modules/@ldclabs/cose-ts/dist/key.js
-var Key = class Key extends KVMap {
-	static fromBytes(data) {
-		return new Key(decodeCBOR(data));
-	}
-	constructor(kv = /* @__PURE__ */ new Map()) {
-		super(kv);
-	}
-	get kty() {
-		return this.getType(1, assertIntOrText, "kty");
-	}
-	set kty(kty) {
-		this.setParam(1, assertIntOrText(kty, "kty"));
-	}
-	get kid() {
-		return this.getBytes(2, "kid");
-	}
-	set kid(kid) {
-		this.setParam(2, assertBytes(kid, "kid"));
-	}
-	get alg() {
-		return this.getType(3, assertIntOrText, "alg");
-	}
-	set alg(alg) {
-		this.setParam(3, assertIntOrText(alg, "alg"));
-	}
-	get ops() {
-		return this.getArray(4, assertIntOrText, "ops");
-	}
-	set ops(ops) {
-		if (!Array.isArray(ops)) throw new TypeError("ops must be an array");
-		ops.forEach((op) => assertIntOrText(op, "ops"));
-		this.setParam(4, ops);
-	}
-	get baseIV() {
-		return this.getBytes(5, "Base IV");
-	}
-	set baseIV(iv) {
-		this.setParam(5, assertBytes(iv, "Base IV"));
-	}
-	getKid() {
-		return decodeCBOR(this.getBytes(2, "kid"));
-	}
-	setKid(kid) {
-		this.setParam(2, encodeCBOR(kid));
-		return this;
-	}
-	getSecret() {
-		switch (this.kty) {
-			case 1: return this.getBytes(-4, "k");
-			case 2: return this.getBytes(-4, "d");
-			case 4: return this.getBytes(-1, "k");
-			default: throw new Error("unsupported key type");
-		}
-	}
-	verifyOps(...allowed) {
-		if (!this.has(4)) return;
-		const ops = this.ops;
-		for (const op of allowed) if (ops.includes(op)) return;
-		throw new Error(`cose-ts: key_ops ${JSON.stringify(ops)} does not permit operation ${allowed.join("/")}`);
-	}
-};
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@ldclabs/cose-ts/1.7.0/a470182239a6259287f50f513c384f2f3f3a1550025b6307427708908f279082/node_modules/@ldclabs/cose-ts/dist/ed25519.js
-/**
-* Ed25519Key implements the Ed25519 signature algorithm (EdDSA) for COSE, as
-* defined in RFC 9053. Use it with {@link Sign1Message} or {@link SignMessage}.
-*
-* Construction signature: `generate(kid?)` — the algorithm is fixed, so the
-* first argument is the optional key id, not the algorithm.
-*
-* @example
-* ```ts
-* const key = Ed25519Key.generate('signing-key-1')
-* const cose = new Sign1Message(payload).toBytes(key)
-* Sign1Message.fromBytes(key.public(), cose)
-* ```
-*
-* @see https://datatracker.ietf.org/doc/html/rfc9053#name-edwards-curve-digital-signa
-*/
-var Ed25519Key = class Ed25519Key extends Key {
-	/** Decodes a COSE_Key from CBOR bytes into an Ed25519Key. */
-	static fromBytes(data) {
-		return new Ed25519Key(decodeCBOR(data));
-	}
-	/**
-	* Generates a new Ed25519 private key from a random 32-byte seed.
-	*
-	* @param kid - Optional key id; stored CBOR-encoded in the COSE_Key and
-	*   copied into the unprotected header by message helpers.
-	*/
-	static generate(kid) {
-		return Ed25519Key.fromSecret(randomBytes$1(32), kid);
-	}
-	/**
-	* Imports an Ed25519 private key from a raw 32-byte seed.
-	*
-	* @param secret - The 32-byte Ed25519 seed (private key).
-	* @param kid - Optional key id.
-	*/
-	static fromSecret(secret, kid) {
-		assertBytes(secret, "secret");
-		if (secret.length !== 32) throw new Error(`cose-ts: Ed25519Key.fromSecret: secret size mismatch, expected 32, got ${secret.length}`);
-		const key = new Ed25519Key();
-		key.setParam(-4, secret);
-		if (kid != null) key.setKid(kid);
-		return key;
-	}
-	/**
-	* Imports an Ed25519 public (verify-only) key from a raw 32-byte point.
-	*
-	* @param pubkey - The 32-byte Ed25519 public key.
-	* @param kid - Optional key id.
-	*/
-	static fromPublic(pubkey, kid) {
-		assertBytes(pubkey, "public key");
-		if (pubkey.length !== 32) throw new Error(`cose-ts: Ed25519Key.fromPublic: public key size mismatch, expected 32, got ${pubkey.length}`);
-		const key = new Ed25519Key();
-		key.setParam(-2, pubkey);
-		if (kid != null) key.setKid(kid);
-		return key;
-	}
-	constructor(kv) {
-		super(kv);
-		this.kty = 1;
-		this.alg = -8;
-		this.setParam(-1, 6);
-	}
-	getSecretKey() {
-		return this.getBytes(-4, "d");
-	}
-	getPublicKey() {
-		if (this.has(-2)) return this.getBytes(-2, "x");
-		return ed25519.getPublicKey(this.getSecretKey());
-	}
-	/**
-	* Returns a verify-only copy of this key: the private seed is removed and
-	* `key_ops` (if present) is narrowed to verify.
-	*/
-	public() {
-		const key = new Ed25519Key(this.clone());
-		if (key.has(-4)) {
-			key.setParam(-2, key.getPublicKey());
-			key.delete(-4);
-		}
-		if (key.has(4)) key.ops = [2];
-		return key;
-	}
-	sign(message) {
-		this.verifyOps(1);
-		return ed25519.sign(message, this.getSecretKey());
-	}
-	verify(message, signature) {
-		this.verifyOps(2);
-		return ed25519.verify(signature, message, this.getPublicKey());
-	}
-};
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@ldclabs/cose-ts/1.7.0/a470182239a6259287f50f513c384f2f3f3a1550025b6307427708908f279082/node_modules/@ldclabs/cose-ts/dist/header.js
-var Header = class Header extends KVMap {
-	static fromBytes(data) {
-		if (data.length === 0) return new Header();
-		return new Header(decodeCBOR(data));
-	}
-	constructor(kv = /* @__PURE__ */ new Map()) {
-		super(kv);
-	}
-	toBytes() {
-		if (this.toRaw().size === 0) return /* @__PURE__ */ new Uint8Array();
-		return super.toBytes();
-	}
-};
-function verifyHeaders(protectedHeader, unprotectedHeader, understoodCriticalLabels) {
-	for (const label of unprotectedHeader.toRaw().keys()) assertIntOrText(label, "unprotected header label");
-	for (const label of protectedHeader.toRaw().keys()) {
-		assertIntOrText(label, "protected header label");
-		if (unprotectedHeader.has(label)) throw new Error(`cose-ts: header parameter ${String(label)} occurs in both the protected and unprotected buckets`);
-	}
-	verifyCommonHeaderParameters(protectedHeader, "protected");
-	verifyCommonHeaderParameters(unprotectedHeader, "unprotected");
-	const hasIV = protectedHeader.has(5) || unprotectedHeader.has(5);
-	const hasPartialIV = protectedHeader.has(6) || unprotectedHeader.has(6);
-	if (hasIV && hasPartialIV) throw new Error("cose-ts: IV and Partial IV must not both be present in the same header layer");
-	if (unprotectedHeader.has(2)) throw new Error("cose-ts: crit header parameter must be in the protected bucket");
-	if (!protectedHeader.has(2)) return [];
-	const crit = protectedHeader.getArray(2, assertIntOrText, "crit");
-	if (crit.length === 0) throw new Error("cose-ts: crit header parameter must have at least one value");
-	for (const label of crit) if (!protectedHeader.has(label)) throw new Error(`cose-ts: critical header parameter ${String(label)} is not present in the protected bucket`);
-	if (understoodCriticalLabels != null) {
-		const understood = new Set(understoodCriticalLabels);
-		for (const label of crit) if (!understood.has(label)) throw new Error(`cose-ts: critical header parameter ${String(label)} is not understood`);
-	}
-	return crit;
-}
-function verifyCommonHeaderParameters(header, bucket) {
-	if (header.has(1)) header.getType(1, assertIntOrText, `${bucket} alg`);
-	if (header.has(3)) header.getType(3, assertContentType, `${bucket} content type`);
-	if (header.has(4)) header.getType(4, assertBytes, `${bucket} kid`);
-	if (header.has(5)) header.getType(5, assertBytes, `${bucket} IV`);
-	if (header.has(6)) header.getType(6, assertBytes, `${bucket} Partial IV`);
-}
-function assertContentType(value, name) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return value;
-	throw new TypeError(`${name} must be a non-negative integer or string, but got ${String(value)}`);
-}
-//#endregion
-//#region ../../../../../../.pnpm-store/v11/links/@ldclabs/cose-ts/1.7.0/a470182239a6259287f50f513c384f2f3f3a1550025b6307427708908f279082/node_modules/@ldclabs/cose-ts/dist/sign1.js
-/**
-* Sign1Message represents a COSE_Sign1 object.
-*
-* The optional externalData argument on toBytes()/fromBytes() is included in
-* the Sig_structure and must match exactly on signing and verification.
-*
-* @example
-* ```ts
-* const key = Ed25519Key.generate()
-* const aad = utf8ToBytes('profile:v1')
-* const cose = new Sign1Message(utf8ToBytes('hello')).toBytes(key, aad)
-* const verified = Sign1Message.fromBytes(key.public(), cose, aad)
-* ```
-*
-* Reference https://datatracker.ietf.org/doc/html/rfc9052#name-signing-with-one-signer
-*/
-var Sign1Message = class Sign1Message {
-	payload;
-	protected = null;
-	unprotected = null;
-	static signBytes(payload, protectedHeader, externalData) {
-		return encodeCBOR([
-			"Signature1",
-			protectedHeader,
-			externalData ?? /* @__PURE__ */ new Uint8Array(),
-			payload
-		]);
-	}
-	static fromBytes(key, coseData, externalData, understoodCriticalLabels) {
-		const [protectedBytes, unprotected, payload, signature] = decodeCBOR(skipTag(Sign1MessagePrefix, skipTag(CwtPrefix, skipTag(CBORSelfPrefix, coseData))));
-		const protectedHeader = Header.fromBytes(protectedBytes);
-		const unprotectedHeader = new Header(unprotected);
-		verifyHeaders(protectedHeader, unprotectedHeader, [1, ...understoodCriticalLabels ?? []]);
-		if (protectedHeader.has(1)) {
-			const alg = protectedHeader.getType(1, assertIntOrText, "alg");
-			if (alg !== key.alg) throw new Error(`cose-ts: Sign1Message.fromBytes: alg mismatch, expected ${alg}, got ${key.alg}`);
-		}
-		if (!key.verify(Sign1Message.signBytes(payload, protectedBytes, externalData), signature)) throw new Error("cose-ts: Sign1Message.fromBytes: signature mismatch");
-		return new Sign1Message(payload, protectedHeader, unprotectedHeader);
-	}
-	static withTag(coseData) {
-		return withTag(Sign1MessagePrefix, coseData);
-	}
-	/**
-	* @param payload - The payload bytes to sign.
-	* @param protectedHeader - Optional protected (authenticated) header. When
-	*   omitted, `toBytes` creates one and sets `alg` from the signing key.
-	* @param unprotected - Optional unprotected header. When omitted, `toBytes`
-	*   creates one and copies the key's `kid` if present.
-	*/
-	constructor(payload, protectedHeader, unprotected) {
-		this.payload = payload;
-		this.protected = protectedHeader ? new Header(protectedHeader.clone()) : null;
-		this.unprotected = unprotected ? new Header(unprotected.clone()) : null;
-	}
-	toBytes(key, externalData) {
-		if (this.protected == null) {
-			this.protected = new Header();
-			if (key.has(3)) this.protected.setParam(1, key.alg);
-		} else if (this.protected.has(1)) {
-			const alg = this.protected.getType(1, assertIntOrText, "alg");
-			if (alg !== key.alg) throw new Error(`cose-ts: Sign1Message.toBytes: alg mismatch, expected ${alg}, got ${key.alg}`);
-		}
-		if (this.unprotected == null) {
-			this.unprotected = new Header();
-			if (key.has(2)) this.unprotected.setParam(4, key.kid);
-		}
-		verifyHeaders(this.protected, this.unprotected);
-		const protectedBytes = this.protected.toBytes();
-		const sig = key.sign(Sign1Message.signBytes(this.payload, protectedBytes, externalData));
-		return encodeCBOR([
-			protectedBytes,
-			this.unprotected.toRaw(),
-			this.payload,
-			sig
-		]);
-	}
-};
-//#endregion
-//#region src/cwt.ts
-var CWT_APP_ID = -65537;
-var CWT_ATTESTATION_PUBLIC_KEY = -65538;
-var CWT_IDENTITY_PUBLIC_KEY = -65539;
-var CWT_PROOF = -65540;
-var IdentityTokenProof = {
-	AppAttest: "app-attest",
-	IdentityKey: "identity-key"
-};
-/**
-* Mint a CWT (CBOR Web Token) with COSE Sign1 envelope, Ed25519 signature.
-*
-* @param privateKey - Ed25519 private key (32 bytes)
-* @param claims - Token claims
-* @returns base64url-encoded CWT
-*/
-function mintIdentityToken(claims, privateKey) {
-	const now = Math.floor(Date.now() / 1e3);
-	const c = new Claims();
-	c.iss = "crayon";
-	c.sub = claims.userId;
-	c.iat = now;
-	c.setParam(CWT_IDENTITY_PUBLIC_KEY, claims.identityPublicKey);
-	c.setParam(CWT_PROOF, claims.proof ?? IdentityTokenProof.AppAttest);
-	if ("appId" in claims) {
-		c.setParam(CWT_APP_ID, claims.appId);
-		c.setParam(CWT_ATTESTATION_PUBLIC_KEY, claims.attestationPublicKey);
-	}
-	const payload = c.toBytes();
-	const key = Ed25519Key.fromSecret(privateKey);
-	const msg = new Sign1Message(payload, new Header().setParam(1, -8));
-	const signed = withCWTTag(Sign1Message.withTag(msg.toBytes(key)));
-	return base64urlnopad.encode(signed);
-}
-/**
-* Verify a CWT and decode its claims.
-*
-* @param publicKey - Ed25519 public key (32 bytes)
-* @param token - base64url-encoded CWT
-* @returns Decoded and verified claims
-* @throws If signature verification fails or token is malformed
-*/
-function verifyIdentityToken(publicKey, token, { expectedClaims, tracer } = {}) {
-	if (!token) throw new Error("Empty token");
-	const encoded = decodeIdentityToken(token);
-	const key = Ed25519Key.fromPublic(publicKey);
-	const msg = traceOperationSync(tracer, "identity.cwt.signature.verify", () => Sign1Message.fromBytes(key, encoded));
-	const c = Claims.fromBytes(msg.payload);
-	let claims;
-	try {
-		claims = VerifiedIdentityTokenSchema.parse({
-			appId: optionalTextClaim(c, CWT_APP_ID),
-			attestationPublicKey: optionalTextClaim(c, CWT_ATTESTATION_PUBLIC_KEY),
-			iat: c.iat,
-			identityPublicKey: c.getText(CWT_IDENTITY_PUBLIC_KEY),
-			proof: optionalTextClaim(c, CWT_PROOF),
-			userId: c.sub
-		});
-	} catch {
-		throw new Error("Malformed CWT claims");
-	}
-	return expectedClaims ? expectedIdentityTokenSchema(expectedClaims).parse(claims) : claims;
-}
-var IdentityTokenProofSchema = z.enum([IdentityTokenProof.AppAttest, IdentityTokenProof.IdentityKey]);
-var RawIdentityTokenSchema = z.object({
-	appId: z.string().optional(),
-	attestationPublicKey: z.string().optional(),
-	iat: z.number(),
-	identityPublicKey: z.string(),
-	proof: IdentityTokenProofSchema.default(IdentityTokenProof.AppAttest),
-	userId: z.string()
-});
-var AppAttestIdentityTokenSchema = z.object({
-	appId: z.string(),
-	attestationPublicKey: z.string(),
-	iat: z.number(),
-	identityPublicKey: z.string(),
-	proof: z.literal(IdentityTokenProof.AppAttest),
-	userId: z.string()
-});
-var IdentityKeyIdentityTokenSchema = z.object({
-	iat: z.number(),
-	identityPublicKey: z.string(),
-	proof: z.literal(IdentityTokenProof.IdentityKey),
-	userId: z.string()
-});
-var VerifiedIdentityTokenSchema = RawIdentityTokenSchema.pipe(z.discriminatedUnion("proof", [AppAttestIdentityTokenSchema, IdentityKeyIdentityTokenSchema]));
-function expectedIdentityTokenSchema(expected) {
-	return expected.proof === IdentityTokenProof.AppAttest ? AppAttestIdentityTokenSchema.extend({
-		appId: z.literal(expected.appId),
-		identityPublicKey: z.literal(expected.identityPublicKey)
-	}) : IdentityKeyIdentityTokenSchema.extend({ identityPublicKey: z.literal(expected.identityPublicKey) });
-}
-function optionalTextClaim(claims, key) {
-	return claims.has(key) ? claims.getText(key) : void 0;
-}
-function decodeIdentityToken(token) {
-	try {
-		return base64urlnopad.decode(token);
-	} catch {
-		return base64url.decode(token);
-	}
-}
-//#endregion
-export { mintIdentityToken as n, verifyIdentityToken as r, IdentityTokenProof as t };