@owf/cose 0.1.0 → 0.2.0-alpha-20260508112151

package/dist/index.cjs

@@ -0,0 +1,1132 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let cbor_x = require("cbor-x");
+let zod = require("zod");
+zod = __toESM(zod);
+let zod_validation_error = require("zod-validation-error");
+let _owf_identity_common = require("@owf/identity-common");
+//#region src/utils/zod-error.ts
+zod.default.config({ customError: (0, zod_validation_error.createErrorMap)() });
+function formatZodError(error) {
+	if (!error) return "";
+	return (0, zod_validation_error.fromError)(error, {
+		prefix: "",
+		prefixSeparator: "✖ ",
+		issueSeparator: "\n✖ ",
+		unionSeparator: "\n    OR ✖ "
+	}).toString();
+}
+var ValidationError = class extends Error {
+	constructor(message, zodError) {
+		super(message);
+		const formattedError = zodError ? formatZodError(zodError) : "";
+		this.message = `${message}\n${formattedError}`;
+		Object.defineProperty(this, "zodError", {
+			value: zodError,
+			writable: false,
+			enumerable: false
+		});
+	}
+};
+//#endregion
+//#region src/utils/zod.ts
+const zUint8Array = zod.default.instanceof(Uint8Array);
+function parseStructureWithErrorHandling(structureName, schema, data, customErrorMessage) {
+	const parseResult = zod.default.safeParse(schema, data);
+	if (!parseResult.success) throw new ValidationError(customErrorMessage ?? `Error decoding ${structureName}`, parseResult.error);
+	return parseResult.data;
+}
+function decodeStructureWithErrorHandling(structureName, schema, data, customErrorMessage) {
+	const decodeResult = zod.default.safeDecode(schema, data);
+	if (!decodeResult.success) throw new ValidationError(customErrorMessage ?? `Error decoding ${structureName}`, decodeResult.error);
+	return decodeResult.data;
+}
+function encodeStructureWithErrorHandling(structureName, schema, data, customErrorMessage) {
+	const encodeResult = zod.default.safeEncode(schema, data);
+	if (!encodeResult.success) throw new ValidationError(customErrorMessage ?? `Error encoding ${structureName}`, encodeResult.error);
+	return encodeResult.data;
+}
+//#endregion
+//#region src/cbor/parser.ts
+const encoderDefaults = {
+	tagUint8Array: false,
+	useRecords: false,
+	mapsAsObjects: false,
+	unwrapTopLevelDataItem: true,
+	variableMapSize: true
+};
+const cborDecode = (input, options = encoderDefaults) => {
+	const params = {
+		...encoderDefaults,
+		...options
+	};
+	const decoded = new cbor_x.Encoder(params).decode(input);
+	return params.unwrapTopLevelDataItem && typeof decoded === "object" && decoded instanceof DataItem ? decoded.data : decoded;
+};
+const cborEncode = (obj, options = encoderDefaults) => {
+	const enc = new cbor_x.Encoder({
+		...encoderDefaults,
+		...options
+	});
+	return Uint8Array.from(enc.encode(obj));
+};
+//#endregion
+//#region src/cbor/data-item.ts
+const zDataItemCodec = (outputSchema) => zod.default.codec(zod.default.instanceof(DataItem), outputSchema, {
+	encode: (data) => DataItem.fromData(data),
+	decode: (dataItem) => dataItem.data
+});
+/**
+* DataItem is an extension defined https://www.rfc-editor.org/rfc/rfc8949.html#name-encoded-cbor-data-item
+*  > Sometimes it is beneficial to carry an embedded CBOR data item that is
+*  > not meant to be decoded immediately at the time the enclosing data item is being decoded.
+*
+* The idea of this class is to provide lazy encode and decode of cbor data.
+*
+* Due to a bug in the cbor-x library, we are eagerly encoding the data in the constructor.
+* https://github.com/kriszyp/cbor-x/issues/83
+*
+*/
+var DataItem = class DataItem {
+	#data;
+	#buffer;
+	constructor(options) {
+		if (!("data" in options) && !("buffer" in options)) throw new Error("DataItem must be initialized with either the data or a buffer");
+		if ("data" in options) this.#data = options.data;
+		this.#buffer = "buffer" in options ? options.buffer : cborEncode(options.data);
+	}
+	get data() {
+		if (!this.#data) this.#data = cborDecode(this.#buffer);
+		return this.#data;
+	}
+	get buffer() {
+		return this.#buffer;
+	}
+	static fromData(data) {
+		return new DataItem({ data });
+	}
+	static fromBuffer(buffer) {
+		return new DataItem({ buffer });
+	}
+};
+(0, cbor_x.addExtension)({
+	Class: DataItem,
+	tag: 24,
+	encode: (instance, encode) => {
+		return encode(instance.buffer);
+	},
+	decode: (buffer) => {
+		return DataItem.fromBuffer(buffer);
+	}
+});
+//#endregion
+//#region src/cbor/cbor-structure.ts
+var CborStructure = class {
+	constructor(structure) {
+		this.structure = structure;
+	}
+	get decodedStructure() {
+		return this.structure;
+	}
+	/**
+	* Static getter for the Zod codec schema that defines the CBOR structure.
+	* Subclasses CAN override this to provide their specific schema for automatic encoding/decoding.
+	* The schema should be a Zod schema or codec that handles validation and transformation.
+	* If not provided, subclasses must override encode(), decode(), and fromEncodedStructure().
+	*/
+	static get encodingSchema() {}
+	/**
+	* Returns the encoded structure that will be serialized to CBOR.
+	* By default, returns the protected structure property.
+	* Override if custom encoding logic is needed.
+	*/
+	get encodedStructure() {
+		const encodingSchema = this.constructor.encodingSchema;
+		if (!encodingSchema) throw new Error("encodedStructure must be implemented when encodingSchema is not provided");
+		return encodeStructureWithErrorHandling(this.constructor.name, encodingSchema, this.structure);
+	}
+	/**
+	* Encodes this structure to CBOR bytes.
+	*/
+	encode(options) {
+		const encodedStructure = options?.asDataItem ? DataItem.fromData(this.encodedStructure) : this.encodedStructure;
+		return cborEncode(this._tag ? new cbor_x.Tag(encodedStructure, this._tag) : encodedStructure);
+	}
+	/**
+	* Decodes CBOR bytes into a structure instance.
+	* Uses the encodingSchema's decode() method to validate and transform the decoded data.
+	*/
+	static decode(bytes) {
+		const rawStructure = cborDecode(bytes);
+		return new this(this.fromEncodedStructure(rawStructure).decodedStructure);
+	}
+	/**
+	* Creates a structure instance from the encoded CBOR structure (after calling cborDecode).
+	*
+	* Uses the encodingSchema's decode() method to validate and transform the structure if available.
+	* Otherwise, subclasses must override this method.
+	*/
+	static fromEncodedStructure(encodedStructure) {
+		if (!this.encodingSchema) throw new Error("fromEncodedStructure must be implemented when encodingSchema is not provided");
+		return new this(decodeStructureWithErrorHandling(this.name, this.encodingSchema, encodedStructure));
+	}
+	static fromDataItem(dataItem) {
+		return new this(parseStructureWithErrorHandling(this.name, zod.z.instanceof(DataItem).transform((di) => di.data).transform((d) => this.fromEncodedStructure(d).decodedStructure), dataItem, `Error decoding ${this.name} from DateItem`));
+	}
+	/**
+	* Creates a structure instance from the decoded structure.
+	*
+	* Uses the encodingSchema's parse method to validate the structure if available.
+	* Otherwise, subclasses must override this method.
+	*/
+	static fromDecodedStructure(decodedStructure) {
+		const encodingSchema = this.encodingSchema;
+		if (!encodingSchema) throw new Error("fromDecodedStructure must be implemented when encodingSchema is not provided");
+		const decodedSchema = encodingSchema instanceof zod.z.ZodPipe ? encodingSchema.out : encodingSchema;
+		return new this(parseStructureWithErrorHandling(this.name, decodedSchema, decodedStructure));
+	}
+};
+//#endregion
+//#region src/cbor/models/date.ts
+(0, cbor_x.addExtension)({
+	Class: Date,
+	tag: 0,
+	encode: (date, encode) => encode(`${date.toISOString().split(".")[0]}Z`),
+	decode: (isoStringDateTime) => new Date(isoStringDateTime)
+});
+//#endregion
+//#region src/cbor/models/date-only.ts
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+var DateOnly = class DateOnly {
+	constructor(date) {
+		this.date = date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	get [Symbol.toStringTag]() {
+		return DateOnly.name;
+	}
+	toString() {
+		return this.toISOString();
+	}
+	toJSON() {
+		return this.toISOString();
+	}
+	toISOString() {
+		return this.date.toISOString().split("T")[0];
+	}
+	[customInspectSymbol]() {
+		return this.toISOString();
+	}
+};
+(0, cbor_x.addExtension)({
+	Class: DateOnly,
+	tag: 1004,
+	encode: (date, encode) => encode(date.toISOString()),
+	decode: (isoStringDate) => new DateOnly(isoStringDate)
+});
+//#endregion
+//#region src/cose/claims/default.ts
+/**
+*
+* Registered CWT claim keys
+* @see https://www.rfc-editor.org/rfc/rfc8392#section-3.1
+*
+*/
+let RegisteredCwtClaimKey = /* @__PURE__ */ function(RegisteredCwtClaimKey) {
+	RegisteredCwtClaimKey[RegisteredCwtClaimKey["Issuer"] = 1] = "Issuer";
+	RegisteredCwtClaimKey[RegisteredCwtClaimKey["Subject"] = 2] = "Subject";
+	RegisteredCwtClaimKey[RegisteredCwtClaimKey["Audience"] = 3] = "Audience";
+	RegisteredCwtClaimKey[RegisteredCwtClaimKey["ExpirationTime"] = 4] = "ExpirationTime";
+	RegisteredCwtClaimKey[RegisteredCwtClaimKey["NotBefore"] = 5] = "NotBefore";
+	RegisteredCwtClaimKey[RegisteredCwtClaimKey["IssuedAt"] = 6] = "IssuedAt";
+	RegisteredCwtClaimKey[RegisteredCwtClaimKey["CwtId"] = 7] = "CwtId";
+	return RegisteredCwtClaimKey;
+}({});
+//#endregion
+//#region src/cose/error.ts
+var CoseError = class extends Error {
+	constructor(message = new.target.name) {
+		super(message);
+	}
+};
+var CoseUnsupportedMacError = class extends CoseError {};
+var CoseInvalidSignatureError = class extends CoseError {};
+var CoseInvalidAlgorithmError = class extends CoseError {};
+var CosePayloadMustBeNullError = class extends CoseError {};
+var CosePayloadMustBeDefinedError = class extends CoseError {};
+var CosePayloadInvalidStructureError = class extends CoseError {};
+var CoseInvalidTypeForKeyError = class extends CoseError {};
+var CoseInvalidValueForKtyError = class extends CoseError {};
+var CoseInvalidKtyForRawError = class extends CoseError {};
+var CoseXNotDefinedError = class extends CoseError {};
+var CoseYNotDefinedError = class extends CoseError {};
+var CoseDNotDefinedError = class extends CoseError {};
+var CoseKNotDefinedError = class extends CoseError {};
+var CoseEphemeralMacKeyIsRequiredError = class extends CoseError {};
+var CoseCertificateNotFoundError = class extends CoseError {};
+var CoseKeyTypeNotSupportedForPrivateKeyExtractionError = class extends CoseError {};
+//#endregion
+//#region src/cose/headers/defaults.ts
+/**
+*
+* Registered CWT header keys
+*
+*/
+let RegisteredCwtHeaderClaimKey = /* @__PURE__ */ function(RegisteredCwtHeaderClaimKey) {
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["Algorithm"] = 1] = "Algorithm";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["Critical"] = 2] = "Critical";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["ContentType"] = 3] = "ContentType";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["KeyId"] = 4] = "KeyId";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["Iv"] = 5] = "Iv";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["PartialIv"] = 6] = "PartialIv";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["CounterSignature"] = 7] = "CounterSignature";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["CounterSignature0"] = 9] = "CounterSignature0";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["CounterSignatureV2"] = 11] = "CounterSignatureV2";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["CounterSignature0V2"] = 12] = "CounterSignature0V2";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["X5Bag"] = 32] = "X5Bag";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["X5Chain"] = 33] = "X5Chain";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["X5T"] = 34] = "X5T";
+	RegisteredCwtHeaderClaimKey[RegisteredCwtHeaderClaimKey["X5U"] = 35] = "X5U";
+	return RegisteredCwtHeaderClaimKey;
+}({});
+let SignatureAlgorithm = /* @__PURE__ */ function(SignatureAlgorithm) {
+	SignatureAlgorithm[SignatureAlgorithm["EdDSA"] = -8] = "EdDSA";
+	SignatureAlgorithm[SignatureAlgorithm["ES256"] = -7] = "ES256";
+	SignatureAlgorithm[SignatureAlgorithm["ES384"] = -35] = "ES384";
+	SignatureAlgorithm[SignatureAlgorithm["ES512"] = -36] = "ES512";
+	SignatureAlgorithm[SignatureAlgorithm["PS256"] = -37] = "PS256";
+	SignatureAlgorithm[SignatureAlgorithm["PS384"] = -38] = "PS384";
+	SignatureAlgorithm[SignatureAlgorithm["PS512"] = -39] = "PS512";
+	SignatureAlgorithm[SignatureAlgorithm["RS256"] = -257] = "RS256";
+	SignatureAlgorithm[SignatureAlgorithm["RS384"] = -258] = "RS384";
+	SignatureAlgorithm[SignatureAlgorithm["RS512"] = -259] = "RS512";
+	return SignatureAlgorithm;
+}({});
+let MacAlgorithm = /* @__PURE__ */ function(MacAlgorithm) {
+	MacAlgorithm[MacAlgorithm["HS256"] = 5] = "HS256";
+	MacAlgorithm[MacAlgorithm["HS384"] = 6] = "HS384";
+	MacAlgorithm[MacAlgorithm["HS512"] = 7] = "HS512";
+	return MacAlgorithm;
+}({});
+let EncryptionAlgorithm = /* @__PURE__ */ function(EncryptionAlgorithm) {
+	EncryptionAlgorithm[EncryptionAlgorithm["A128GCM"] = 1] = "A128GCM";
+	EncryptionAlgorithm[EncryptionAlgorithm["A192GCM"] = 2] = "A192GCM";
+	EncryptionAlgorithm[EncryptionAlgorithm["A256GCM"] = 3] = "A256GCM";
+	EncryptionAlgorithm[EncryptionAlgorithm["Direct"] = -6] = "Direct";
+	return EncryptionAlgorithm;
+}({});
+//#endregion
+//#region src/cose/headers/protected-headers.ts
+const protectedHeadersEncodedStructure = zUint8Array;
+const protectedHeadersDecodedStructure = zod.default.map(zod.default.number(), zod.default.unknown());
+var ProtectedHeaders = class ProtectedHeaders extends CborStructure {
+	static get encodingSchema() {
+		return zod.default.codec(protectedHeadersEncodedStructure, protectedHeadersDecodedStructure, {
+			encode: (decoded) => cborEncode(decoded),
+			decode: (encoded) => cborDecode(encoded)
+		});
+	}
+	get headers() {
+		return this.structure;
+	}
+	static create(options) {
+		return ProtectedHeaders.fromDecodedStructure(options.protectedHeaders ?? /* @__PURE__ */ new Map());
+	}
+};
+//#endregion
+//#region src/cose/headers/unprotected-headers.ts
+const unprotectedHeadersStructure = zod.default.map(zod.default.number(), zod.default.unknown());
+var UnprotectedHeaders = class UnprotectedHeaders extends CborStructure {
+	static get encodingSchema() {
+		return unprotectedHeadersStructure;
+	}
+	get headers() {
+		return this.structure;
+	}
+	static create(options) {
+		return UnprotectedHeaders.fromDecodedStructure(options.unprotectedHeaders ?? /* @__PURE__ */ new Map());
+	}
+};
+//#endregion
+//#region src/cose/key/curve.ts
+let Curve = /* @__PURE__ */ function(Curve) {
+	Curve[Curve["P-256"] = 1] = "P-256";
+	Curve[Curve["P-384"] = 2] = "P-384";
+	Curve[Curve["P-521"] = 3] = "P-521";
+	Curve[Curve["X25519"] = 4] = "X25519";
+	Curve[Curve["X448"] = 5] = "X448";
+	Curve[Curve["Ed25519"] = 6] = "Ed25519";
+	Curve[Curve["Ed448"] = 7] = "Ed448";
+	return Curve;
+}({});
+//#endregion
+//#region src/cose/key/key-operation.ts
+let KeyOps = /* @__PURE__ */ function(KeyOps) {
+	KeyOps[KeyOps["Sign"] = 1] = "Sign";
+	KeyOps[KeyOps["Verify"] = 2] = "Verify";
+	KeyOps[KeyOps["Encrypt"] = 3] = "Encrypt";
+	KeyOps[KeyOps["Decrypt"] = 4] = "Decrypt";
+	KeyOps[KeyOps["WrapKey"] = 5] = "WrapKey";
+	KeyOps[KeyOps["UnwrapKey"] = 6] = "UnwrapKey";
+	KeyOps[KeyOps["DeriveKey"] = 7] = "DeriveKey";
+	KeyOps[KeyOps["DeriveBits"] = 8] = "DeriveBits";
+	KeyOps[KeyOps["MACCreate"] = 9] = "MACCreate";
+	KeyOps[KeyOps["MACVerify"] = 10] = "MACVerify";
+	return KeyOps;
+}({});
+//#endregion
+//#region src/cose/key/key-type.ts
+let KeyType = /* @__PURE__ */ function(KeyType) {
+	KeyType[KeyType["Okp"] = 1] = "Okp";
+	KeyType[KeyType["Ec"] = 2] = "Ec";
+	KeyType[KeyType["Oct"] = 4] = "Oct";
+	KeyType[KeyType["Reserved"] = 0] = "Reserved";
+	return KeyType;
+}({});
+//#endregion
+//#region src/cose/key/jwk.ts
+const swapMap = (map) => Object.fromEntries(Object.entries(map).map(([key, value]) => [value, key]));
+const swapNestedMap = (nestedMap) => Object.fromEntries(Object.entries(nestedMap).map(([category, mappings]) => [category, Object.fromEntries(Object.entries(mappings).map(([key, value]) => [value, key]))]));
+const jwkCoseKeyMap = {
+	kty: {
+		OKP: 1,
+		EC: 2,
+		OCT: 4
+	},
+	crv: {
+		"P-256": 1,
+		"p-384": 2,
+		"p-521": 3,
+		X25519: 4,
+		Ed25519: 6,
+		Ed448: 7
+	},
+	alg: {
+		EdDSA: -8,
+		ES256: -7,
+		ES384: -35,
+		ES512: -36,
+		PS256: -37,
+		PS384: -38,
+		PS512: -39,
+		RS256: -257,
+		RS384: -258,
+		RS512: -259,
+		HS256: 5,
+		HS384: 6,
+		HS512: 7,
+		A128GCM: 1,
+		A192GCM: 2,
+		A256GCM: 3,
+		Direct: -6
+	},
+	keyOps: {
+		sign: 1,
+		verify: 2,
+		encrypt: 3,
+		decrypt: 4,
+		wrapKey: 5,
+		unwrapKey: 6,
+		deriveKey: 7,
+		deriveBits: 8,
+		mACCreate: 9,
+		mACVerify: 10
+	}
+};
+const coseKeyJwkMap = swapNestedMap(jwkCoseKeyMap);
+const jwkCoseOptionsMap = {
+	kty: "keyType",
+	kid: "keyId",
+	alg: "algorithm",
+	keyOps: "keyOps",
+	baseIv: "baseIv",
+	crv: "curve",
+	x: "x",
+	y: "y",
+	d: "d"
+};
+const coseOptionsJwkMap = swapMap(jwkCoseOptionsMap);
+const jwkToCoseKey = {
+	kty: (kty) => {
+		return jwkCoseKeyMap.kty[kty] ?? kty;
+	},
+	crv: (crv) => jwkCoseKeyMap.crv[crv] ?? crv,
+	alg: (alg) => jwkCoseKeyMap.alg[alg] ?? alg,
+	kid: (kid) => kid,
+	keyOps: (keyOps) => Array.isArray(keyOps) ? keyOps?.map((ko) => jwkCoseKeyMap.keyOps[ko] ?? ko) : void 0,
+	x: (s) => s && typeof s === "string" ? _owf_identity_common.base64url.decode(s) : void 0,
+	y: (s) => s && typeof s === "string" ? _owf_identity_common.base64url.decode(s) : void 0,
+	d: (s) => s && typeof s === "string" ? _owf_identity_common.base64url.decode(s) : void 0
+};
+const coseKeyToJwk = {
+	keyType: (keyType) => coseKeyJwkMap.kty[keyType],
+	keyId: (keyId) => keyId,
+	algorithm: (algorithm) => algorithm ? coseKeyJwkMap.alg[algorithm] : void 0,
+	keyOps: (keyOps) => keyOps && Array.isArray(keyOps) ? keyOps.map((ko) => coseKeyJwkMap.keyOps[ko]) : void 0,
+	baseIv: (baseIv) => baseIv,
+	curve: (curve) => curve ? coseKeyJwkMap.crv[curve] : void 0,
+	x: (x) => x ? _owf_identity_common.base64url.encode(x) : void 0,
+	y: (y) => y ? _owf_identity_common.base64url.encode(y) : void 0,
+	d: (d) => d ? _owf_identity_common.base64url.encode(d) : void 0
+};
+//#endregion
+//#region src/cose/mac0.ts
+const mac0EncodedSchema = zod.z.tuple([
+	zUint8Array,
+	zod.z.map(zod.z.unknown(), zod.z.unknown()),
+	zUint8Array.nullable(),
+	zUint8Array
+]);
+const mac0DecodedSchema = zod.z.object({
+	protectedHeaders: zod.z.instanceof(ProtectedHeaders),
+	unprotectedHeaders: zod.z.instanceof(UnprotectedHeaders),
+	payload: zUint8Array.nullable(),
+	tag: zUint8Array
+});
+var Mac0 = class Mac0 extends CborStructure {
+	constructor(..._args) {
+		super(..._args);
+		this._tag = Mac0.tag;
+	}
+	static {
+		this.tag = 17;
+	}
+	static get encodingSchema() {
+		return zod.z.codec(mac0EncodedSchema, mac0DecodedSchema, {
+			encode: ({ protectedHeaders, unprotectedHeaders, payload, tag }) => {
+				if (tag.length === 0) throw new Error("Tag has not been set. Required for encoding the mac0 structure");
+				return [
+					protectedHeaders.encodedStructure,
+					unprotectedHeaders.encodedStructure,
+					payload,
+					tag
+				];
+			},
+			decode: ([protectedHeadersBytes, unprotectedHeadersMap, payload, tag]) => ({
+				protectedHeaders: ProtectedHeaders.fromEncodedStructure(protectedHeadersBytes),
+				unprotectedHeaders: UnprotectedHeaders.fromEncodedStructure(unprotectedHeadersMap),
+				payload,
+				tag
+			})
+		});
+	}
+	get protectedHeaders() {
+		return this.structure.protectedHeaders;
+	}
+	get unprotectedHeaders() {
+		return this.structure.unprotectedHeaders;
+	}
+	get payload() {
+		return this.structure.payload;
+	}
+	get tag() {
+		return this.structure.tag;
+	}
+	get toBeAuthenticated() {
+		const payload = this.payload ?? this.detachedPayload;
+		if (!payload) throw new CosePayloadMustBeDefinedError();
+		return Mac0.toBeAuthenticated({
+			payload,
+			protectedHeaders: this.protectedHeaders,
+			externalAad: this.externalAad
+		});
+	}
+	/**
+	* Decodes CBOR bytes into a Sign1 instance.
+	* Uses the encodingSchema's decode() method to validate and transform the decoded data.
+	*/
+	static decode(bytes) {
+		const rawStructure = cborDecode(bytes);
+		return new Mac0(rawStructure instanceof Mac0 ? rawStructure.decodedStructure : Mac0.fromEncodedStructure(rawStructure).decodedStructure);
+	}
+	static toBeAuthenticated(options) {
+		const toBeAuthenticated = ["MAC0", options.protectedHeaders.encodedStructure];
+		if (options.externalAad) toBeAuthenticated.push(options.externalAad);
+		toBeAuthenticated.push(options.payload);
+		return cborEncode(toBeAuthenticated);
+	}
+	get signatureAlgorithmName() {
+		const algorithm = this.protectedHeaders.headers?.get(1) ?? this.unprotectedHeaders.headers?.get(1);
+		if (!algorithm) throw new CoseInvalidAlgorithmError();
+		const algorithmName = coseKeyToJwk.algorithm(algorithm);
+		if (!algorithmName) throw new CoseInvalidAlgorithmError();
+		return algorithmName;
+	}
+	static create(options) {
+		const protectedHeaders = options.protectedHeaders instanceof ProtectedHeaders ? options.protectedHeaders : ProtectedHeaders.create({ protectedHeaders: options.protectedHeaders });
+		const unprotectedHeaders = options.unprotectedHeaders instanceof UnprotectedHeaders ? options.unprotectedHeaders : UnprotectedHeaders.create({ unprotectedHeaders: options.unprotectedHeaders });
+		if (!(options.payload ?? options.detachedPayload)) throw new CosePayloadMustBeDefinedError();
+		const mac0 = new Mac0({
+			protectedHeaders,
+			unprotectedHeaders,
+			payload: options.payload ?? null,
+			tag: new Uint8Array()
+		});
+		mac0.externalAad = options.externalAad;
+		mac0.detachedPayload = options.detachedPayload;
+		return mac0;
+	}
+	async authenticate(options, ctx) {
+		const payload = this.payload ?? this.detachedPayload;
+		if (!payload) throw new CosePayloadMustBeDefinedError();
+		this.structure.tag = await ctx.mac({
+			toBeAuthenticated: Mac0.toBeAuthenticated({
+				payload,
+				protectedHeaders: this.protectedHeaders,
+				externalAad: this.externalAad
+			}),
+			key: options.key
+		});
+		return this;
+	}
+};
+(0, cbor_x.addExtension)({
+	Class: Mac0,
+	tag: Mac0.tag,
+	encode(instance, encodeFn) {
+		return encodeFn(instance);
+	},
+	decode: (encoded) => Mac0.fromEncodedStructure(encoded)
+});
+//#endregion
+//#region src/utils/typed-map.ts
+/**
+* TypedMap provides compile-time type safety for Maps where each key has its own specific value type.
+* Unlike Map<K, V> which has the same value type V for all keys, TypedMap<Schema, OptionalKeys>
+* allows different value types per key (heterogeneous values).
+*
+* Example:
+*   type CoseKeySchema = {
+*     [CoseKeyParameter.KeyType]: KeyType     // number key → KeyType value
+*     [CoseKeyParameter.Curve]: Curve         // number key → Curve value
+*     [CoseKeyParameter.X]: Uint8Array        // number key → Uint8Array value
+*   }
+*
+*   const map = new TypedMap<CoseKeySchema>()
+*   map.get(CoseKeyParameter.KeyType)  // TypeScript knows this is KeyType!
+*   map.get(CoseKeyParameter.Curve)    // TypeScript knows this is Curve!
+*   map.get(CoseKeyParameter.X)        // TypeScript knows this is Uint8Array!
+*
+* @template Schema - Object type mapping keys to their value types
+* @template OptionalKeys - Union of keys that are optional (can be absent)
+*/
+var TypedMap = class TypedMap {
+	constructor(entries) {
+		this.map = new Map(entries);
+	}
+	static fromMap(map) {
+		return new TypedMap(Array.from(map.entries()));
+	}
+	static fromObject(object) {
+		return new TypedMap(Array.from(Object.entries(object)));
+	}
+	/**
+	* Type-safe get that returns the correct value type for each key.
+	* Required keys return T, optional keys return T | undefined.
+	*/
+	get(key) {
+		return this.map.get(key);
+	}
+	/**
+	* Type-safe set that ensures the value matches the key's type
+	*/
+	set(key, value) {
+		this.map.set(key, value);
+		return this;
+	}
+	has(key) {
+		return this.map.has(key);
+	}
+	delete(key) {
+		return this.map.delete(key);
+	}
+	clear() {
+		this.map.clear();
+	}
+	get size() {
+		return this.map.size;
+	}
+	keys() {
+		return this.map.keys();
+	}
+	values() {
+		return this.map.values();
+	}
+	entries() {
+		return this.map.entries();
+	}
+	forEach(callbackfn, thisArg) {
+		this.map.forEach(callbackfn, thisArg);
+	}
+	[Symbol.iterator]() {
+		return this.map[Symbol.iterator]();
+	}
+	toMap() {
+		return new Map(this.map);
+	}
+};
+/**
+* This checks whether the property is exact optional. exact optional means that the value cannot be undefined, but if used
+* in an object the key can be omitted. This is important for CBOR structures, as undefined will be encoded, and thus must be
+* omitted in most cases.
+*
+* Zod recommend to check for optionality by just parsing undefined.
+*/
+const isExactOptional = (schema) => !schema.safeParse(void 0).success && zod.z.object({ test: schema }).safeParse({}).success;
+/**
+* Utility function to create a typed map codec.
+* Takes an array of [key, valueSchema] entries to support any key type (including non-string keys for CBOR).
+*
+* Example:
+*   const coseKeyMap = typedMap([
+*     [CoseKeyParameter.KeyType, z.number()],
+*     [CoseKeyParameter.Curve, z.number()],
+*     [CoseKeyParameter.X, z.instanceof(Uint8Array)]
+*   ] as const)
+*
+* The resulting schema validates a Map and transforms it to TypedMap<Schema, never>.
+*/
+function typedMap(entries, { allowAdditionalKeys = true, encode, decode } = {}) {
+	const requiredKeys = entries.filter(([, valueSchema]) => !isExactOptional(valueSchema)).map(([key]) => key);
+	const schemaMap = new Map(entries);
+	const originalEncode = (decoded) => decoded.toMap();
+	const originalDecode = (encoded) => TypedMap.fromMap(encoded);
+	return zod.z.codec(zod.z.map(zod.z.unknown(), zod.z.unknown()), zod.z.instanceof(TypedMap).superRefine((map, ctx) => {
+		const additionalKeys = Array.from(map.keys()).filter((key) => !schemaMap.has(key));
+		if (additionalKeys.length > 0 && !allowAdditionalKeys) for (const additionalKey of additionalKeys) if (typeof additionalKey !== "string" && typeof additionalKey !== "number") ctx.addIssue({
+			code: "invalid_key",
+			origin: "map",
+			continue: true,
+			path: [],
+			input: map,
+			issues: [],
+			message: "Key found in map that is not a string or number"
+		});
+		else ctx.addIssue({
+			code: "invalid_key",
+			origin: "map",
+			continue: true,
+			path: [additionalKey],
+			input: map,
+			issues: [],
+			message: `Unexpected key '${additionalKey}' found in map, additional keys are not allowed.`
+		});
+		for (const [key, valueSchema] of schemaMap.entries()) {
+			const hasKey = map.has(key);
+			const value = map.get(key);
+			if (!hasKey && requiredKeys.includes(key)) {
+				ctx.addIssue({
+					code: "invalid_value",
+					continue: true,
+					message: `Expected key '${key}' to be defined.`,
+					path: [key],
+					values: [],
+					input: value
+				});
+				continue;
+			}
+			if (!hasKey && !requiredKeys.includes(key)) continue;
+			const parseResult = valueSchema.safeParse(value);
+			if (!parseResult.success) for (const issue of parseResult.error.issues) ctx.addIssue({
+				...issue,
+				path: [`${key}`, ...issue.path]
+			});
+		}
+	}), {
+		decode: (input) => decode ? decode(input, originalDecode) : originalDecode(input),
+		encode: (output) => encode ? encode(output, originalEncode) : originalEncode(output)
+	});
+}
+//#endregion
+//#region src/cose/key/key.ts
+let CoseKeyParameter = /* @__PURE__ */ function(CoseKeyParameter) {
+	CoseKeyParameter[CoseKeyParameter["KeyType"] = 1] = "KeyType";
+	CoseKeyParameter[CoseKeyParameter["KeyId"] = 2] = "KeyId";
+	CoseKeyParameter[CoseKeyParameter["Algorithm"] = 3] = "Algorithm";
+	CoseKeyParameter[CoseKeyParameter["KeyOps"] = 4] = "KeyOps";
+	CoseKeyParameter[CoseKeyParameter["BaseIv"] = 5] = "BaseIv";
+	CoseKeyParameter[CoseKeyParameter["CurveOrK"] = -1] = "CurveOrK";
+	CoseKeyParameter[CoseKeyParameter["X"] = -2] = "X";
+	CoseKeyParameter[CoseKeyParameter["Y"] = -3] = "Y";
+	CoseKeyParameter[CoseKeyParameter["D"] = -4] = "D";
+	return CoseKeyParameter;
+}({});
+const coseKeySchema = typedMap([
+	[1, zod.z.union([zod.z.enum(KeyType), zod.z.string()])],
+	[2, zUint8Array.or(zod.z.string()).exactOptional()],
+	[3, zod.z.union([zod.z.string({ error: "Cose algorithm must be a string" }), zod.z.number({ error: "Cose algorithm must be a number" })]).exactOptional()],
+	[4, zod.z.array(zod.z.union([zod.z.enum(KeyOps), zod.z.string()])).exactOptional()],
+	[5, zUint8Array.exactOptional()],
+	[-1, zod.z.union([zod.z.enum(Curve), zUint8Array]).exactOptional()],
+	[-2, zUint8Array.exactOptional()],
+	[-3, zUint8Array.exactOptional()],
+	[-4, zUint8Array.exactOptional()]
+]);
+var CoseKey = class CoseKey extends CborStructure {
+	static get encodingSchema() {
+		return coseKeySchema;
+	}
+	get keyType() {
+		return this.structure.get(1);
+	}
+	get keyId() {
+		const keyId = this.structure.get(2);
+		return keyId instanceof Uint8Array ? (0, _owf_identity_common.bytesToString)(keyId) : keyId;
+	}
+	get algorithm() {
+		return this.structure.get(3);
+	}
+	get keyOps() {
+		return this.structure.get(4);
+	}
+	get baseIv() {
+		return this.structure.get(5);
+	}
+	get curve() {
+		if (this.keyType === 2 || this.keyType === 1) return this.structure.get(-1);
+	}
+	get x() {
+		return this.structure.get(-2);
+	}
+	get y() {
+		return this.structure.get(-3);
+	}
+	get d() {
+		return this.structure.get(-4);
+	}
+	get k() {
+		if (this.keyType === 4) return this.structure.get(-1);
+	}
+	static create(options) {
+		const map = new TypedMap([[1, options.keyType]]);
+		if (options.keyId !== void 0) map.set(2, (0, _owf_identity_common.stringToBytes)(options.keyId));
+		if (options.algorithm !== void 0) map.set(3, options.algorithm);
+		if (options.keyOps !== void 0) map.set(4, options.keyOps);
+		if (options.baseIv !== void 0) map.set(5, options.baseIv);
+		if (options.curve !== void 0) map.set(-1, options.curve);
+		if (options.x !== void 0) map.set(-2, options.x);
+		if (options.y !== void 0) map.set(-3, options.y);
+		if (options.d !== void 0) map.set(-4, options.d);
+		if (options.k !== void 0) map.set(-1, options.k);
+		return CoseKey.fromDecodedStructure(map);
+	}
+	static fromJwk(jwk) {
+		if (!("kty" in jwk)) throw new CoseInvalidValueForKtyError("JWK does not contain required kty value");
+		const options = Object.entries(jwk).reduce((prev, [key, value]) => {
+			const mappedKey = jwkCoseOptionsMap[key] ?? key;
+			const mapFunction = jwkToCoseKey[key];
+			const convertedValue = mapFunction ? mapFunction(value) : value;
+			if (convertedValue !== void 0) return {
+				...prev,
+				[mappedKey]: convertedValue
+			};
+			return prev;
+		}, {});
+		return CoseKey.create(options);
+	}
+	get publicKey() {
+		if (this.keyType !== 2) throw new CoseInvalidKtyForRawError();
+		if (!this.x) throw new CoseXNotDefinedError();
+		if (!this.y) throw new CoseYNotDefinedError();
+		return (0, _owf_identity_common.concatBytes)(Uint8Array.from([4]), this.x, this.y);
+	}
+	get privateKey() {
+		if (this.keyType === 2) {
+			if (!this.d) throw new CoseDNotDefinedError();
+			return this.d;
+		}
+		if (this.keyType === 4) {
+			if (!this.k) throw new CoseKNotDefinedError();
+			return this.k;
+		}
+		throw new CoseKeyTypeNotSupportedForPrivateKeyExtractionError();
+	}
+	get jwk() {
+		const options = {
+			keyType: this.keyType,
+			keyId: this.keyId,
+			algorithm: this.algorithm,
+			keyOps: this.keyOps,
+			baseIv: this.baseIv,
+			curve: this.curve,
+			x: this.x,
+			y: this.y,
+			d: this.d,
+			k: this.k
+		};
+		return Object.entries(options).reduce((prev, [key, value]) => ({
+			...prev,
+			[coseOptionsJwkMap[key] ?? key]: typeof coseKeyToJwk[key] === "function" ? coseKeyToJwk[key](value) : void 0
+		}), {});
+	}
+};
+//#endregion
+//#region src/cose/sign1.ts
+const sign1EncodedSchema = zod.default.tuple([
+	protectedHeadersEncodedStructure,
+	unprotectedHeadersStructure,
+	zUint8Array.nullable(),
+	zUint8Array
+]);
+const sign1DecodedSchema = zod.default.object({
+	protectedHeaders: zod.default.instanceof(ProtectedHeaders),
+	unprotectedHeaders: zod.default.instanceof(UnprotectedHeaders),
+	payload: sign1EncodedSchema.def.items[2],
+	signature: sign1EncodedSchema.def.items[3]
+});
+var Sign1 = class Sign1 extends CborStructure {
+	constructor(..._args) {
+		super(..._args);
+		this._tag = Sign1.tag;
+	}
+	static {
+		this.tag = 18;
+	}
+	static get encodingSchema() {
+		return zod.default.codec(sign1EncodedSchema, sign1DecodedSchema, {
+			encode: (decoded) => {
+				if (decoded.signature.length === 0) throw new Error("Signature has not been set. Required for encoding the sign1 structure");
+				return [
+					decoded.protectedHeaders.encodedStructure,
+					decoded.unprotectedHeaders.encodedStructure,
+					decoded.payload,
+					decoded.signature
+				];
+			},
+			decode: ([protectedHeaders, unprotected, payload, signature]) => ({
+				protectedHeaders: ProtectedHeaders.fromEncodedStructure(protectedHeaders),
+				unprotectedHeaders: UnprotectedHeaders.fromEncodedStructure(unprotected),
+				payload,
+				signature
+			})
+		});
+	}
+	get protectedHeaders() {
+		return this.structure.protectedHeaders;
+	}
+	get unprotectedHeaders() {
+		return this.structure.unprotectedHeaders;
+	}
+	get payload() {
+		return this.structure.payload;
+	}
+	get signature() {
+		return this.structure.signature;
+	}
+	get certificateChain() {
+		return this.x5chain ?? [];
+	}
+	get certificate() {
+		const [certificate] = this.certificateChain;
+		if (!certificate) throw new CoseCertificateNotFoundError();
+		return certificate;
+	}
+	getIssuingCountry(ctx) {
+		return ctx.x509.getIssuerNameField({
+			certificate: this.certificate,
+			field: "C"
+		})[0];
+	}
+	getIssuingStateOrProvince(ctx) {
+		return ctx.x509.getIssuerNameField({
+			certificate: this.certificate,
+			field: "ST"
+		})[0];
+	}
+	get toBeSigned() {
+		const payload = this.payload ?? this.detachedPayload;
+		if (!payload) throw new CosePayloadMustBeDefinedError();
+		return Sign1.toBeSigned({
+			payload,
+			protectedHeaders: this.protectedHeaders,
+			externalAad: this.externalAad
+		});
+	}
+	/**
+	* Decodes CBOR bytes into a Sign1 instance.
+	* Uses the encodingSchema's decode() method to validate and transform the decoded data.
+	*/
+	static decode(bytes) {
+		const rawStructure = cborDecode(bytes);
+		return new Sign1(rawStructure instanceof Sign1 ? rawStructure.decodedStructure : Sign1.fromEncodedStructure(rawStructure).decodedStructure);
+	}
+	static toBeSigned(options) {
+		return cborEncode([
+			"Signature1",
+			options.protectedHeaders.encodedStructure,
+			options.externalAad ?? new Uint8Array(),
+			options.payload
+		]);
+	}
+	get signatureAlgorithmName() {
+		const algorithm = this.protectedHeaders.headers?.get(1) ?? this.unprotectedHeaders.headers?.get(1);
+		if (!algorithm) throw new CoseInvalidAlgorithmError();
+		const algorithmName = coseKeyToJwk.algorithm(algorithm);
+		if (!algorithmName) throw new CoseInvalidAlgorithmError();
+		return algorithmName;
+	}
+	get x5chain() {
+		const x5chain = this.protectedHeaders.headers?.get(33) ?? this.unprotectedHeaders.headers?.get(33);
+		if (!x5chain?.[0]) return;
+		return Array.isArray(x5chain) ? x5chain : [x5chain];
+	}
+	async verifySignature(options, ctx) {
+		const publicKey = options.key ?? (this.certificate ? await ctx.getPublicKey({
+			certificate: this.certificate,
+			alg: this.signatureAlgorithmName
+		}) : void 0);
+		if (!publicKey) throw new CoseCertificateNotFoundError();
+		return await ctx.verify({
+			sign1: this,
+			key: publicKey
+		});
+	}
+	static create(options) {
+		const payload = options.payload ?? options.detachedPayload;
+		if (!payload) throw new CosePayloadMustBeDefinedError();
+		const sign1 = new Sign1({
+			protectedHeaders: options.protectedHeaders instanceof ProtectedHeaders ? options.protectedHeaders : options.protectedHeaders ? ProtectedHeaders.fromDecodedStructure(options.protectedHeaders) : ProtectedHeaders.create({}),
+			unprotectedHeaders: options.unprotectedHeaders instanceof UnprotectedHeaders ? options.unprotectedHeaders : options.unprotectedHeaders ? UnprotectedHeaders.fromDecodedStructure(options.unprotectedHeaders) : UnprotectedHeaders.create({}),
+			payload,
+			signature: new Uint8Array()
+		});
+		sign1.externalAad = options.externalAad;
+		sign1.detachedPayload = options.detachedPayload;
+		return sign1;
+	}
+	async sign(options, ctx) {
+		const payload = this.payload ?? options.detachedPayload;
+		if (!payload) throw new CosePayloadMustBeDefinedError();
+		const signatureAlgorithm = options.algorithm ?? options.signingKey.algorithm;
+		if (!signatureAlgorithm) throw new CoseInvalidAlgorithmError("Could not establish signature algorithm. Either provide it in the options directly, or provide it in the signingKey");
+		this.structure.signature = await ctx.sign({
+			toBeSigned: Sign1.toBeSigned({
+				payload,
+				protectedHeaders: this.protectedHeaders,
+				externalAad: options.externalAad
+			}),
+			key: options.signingKey,
+			algorithm: signatureAlgorithm
+		});
+		return this;
+	}
+};
+(0, cbor_x.addExtension)({
+	Class: Sign1,
+	tag: Sign1.tag,
+	encode(instance, encodeFn) {
+		return encodeFn(instance);
+	},
+	decode: (encoded) => Sign1.fromEncodedStructure(encoded)
+});
+//#endregion
+//#region src/cose/cwt.ts
+var Cwt = class Cwt {
+	constructor(options) {
+		this.options = options;
+	}
+	static create(options) {
+		return new Cwt(options);
+	}
+	static fromToken(token) {
+		return new Cwt(cborDecode(token));
+	}
+	get asSign1() {
+		return Sign1.create(this.options);
+	}
+	get asMac0() {
+		return Mac0.create(this.options);
+	}
+	get payload() {
+		const payload = this.options.payload ?? this.options.detachedPayload;
+		if (!payload) throw new Error("Neither `payload`, nor `detachedPayload` is defined");
+		return payload;
+	}
+	get protectedHeaders() {
+		return this.options.protectedHeaders;
+	}
+	get unprotectedHeaders() {
+		return this.options.unprotectedHeaders;
+	}
+};
+//#endregion
+exports.CborStructure = CborStructure;
+exports.CoseCertificateNotFoundError = CoseCertificateNotFoundError;
+exports.CoseDNotDefinedError = CoseDNotDefinedError;
+exports.CoseEphemeralMacKeyIsRequiredError = CoseEphemeralMacKeyIsRequiredError;
+exports.CoseInvalidAlgorithmError = CoseInvalidAlgorithmError;
+exports.CoseInvalidKtyForRawError = CoseInvalidKtyForRawError;
+exports.CoseInvalidSignatureError = CoseInvalidSignatureError;
+exports.CoseInvalidTypeForKeyError = CoseInvalidTypeForKeyError;
+exports.CoseInvalidValueForKtyError = CoseInvalidValueForKtyError;
+exports.CoseKNotDefinedError = CoseKNotDefinedError;
+exports.CoseKey = CoseKey;
+exports.CoseKeyParameter = CoseKeyParameter;
+exports.CoseKeyTypeNotSupportedForPrivateKeyExtractionError = CoseKeyTypeNotSupportedForPrivateKeyExtractionError;
+exports.CosePayloadInvalidStructureError = CosePayloadInvalidStructureError;
+exports.CosePayloadMustBeDefinedError = CosePayloadMustBeDefinedError;
+exports.CosePayloadMustBeNullError = CosePayloadMustBeNullError;
+exports.CoseUnsupportedMacError = CoseUnsupportedMacError;
+exports.CoseXNotDefinedError = CoseXNotDefinedError;
+exports.CoseYNotDefinedError = CoseYNotDefinedError;
+exports.Curve = Curve;
+exports.Cwt = Cwt;
+exports.DataItem = DataItem;
+exports.DateOnly = DateOnly;
+exports.EncryptionAlgorithm = EncryptionAlgorithm;
+exports.KeyOps = KeyOps;
+exports.KeyType = KeyType;
+exports.Mac0 = Mac0;
+exports.MacAlgorithm = MacAlgorithm;
+exports.ProtectedHeaders = ProtectedHeaders;
+exports.RegisteredCwtClaimKey = RegisteredCwtClaimKey;
+exports.RegisteredCwtHeaderClaimKey = RegisteredCwtHeaderClaimKey;
+exports.Sign1 = Sign1;
+exports.SignatureAlgorithm = SignatureAlgorithm;
+exports.TypedMap = TypedMap;
+exports.UnprotectedHeaders = UnprotectedHeaders;
+exports.ValidationError = ValidationError;
+Object.defineProperty(exports, "addExtension", {
+	enumerable: true,
+	get: function() {
+		return cbor_x.addExtension;
+	}
+});
+exports.cborDecode = cborDecode;
+exports.cborEncode = cborEncode;
+exports.coseKeyToJwk = coseKeyToJwk;
+exports.coseOptionsJwkMap = coseOptionsJwkMap;
+exports.jwkCoseOptionsMap = jwkCoseOptionsMap;
+exports.jwkToCoseKey = jwkToCoseKey;
+exports.mac0DecodedSchema = mac0DecodedSchema;
+exports.mac0EncodedSchema = mac0EncodedSchema;
+exports.protectedHeadersDecodedStructure = protectedHeadersDecodedStructure;
+exports.protectedHeadersEncodedStructure = protectedHeadersEncodedStructure;
+exports.sign1DecodedSchema = sign1DecodedSchema;
+exports.sign1EncodedSchema = sign1EncodedSchema;
+exports.typedMap = typedMap;
+exports.unprotectedHeadersStructure = unprotectedHeadersStructure;
+exports.zDataItemCodec = zDataItemCodec;
+exports.zUint8Array = zUint8Array;
+
+//# sourceMappingURL=index.cjs.map