@sd-jwt/core 0.20.1 → 0.21.0-alpha-20260916100413

package/dist/index.cjs

@@ -0,0 +1,1526 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _owf_identity_common = require("@owf/identity-common");
+//#region src/types/type.ts
+const SD_SEPARATOR = "~";
+const SD_LIST_KEY = "...";
+const SD_DIGEST = "_sd";
+const SD_DECOY = "_sd_decoy";
+const KB_JWT_TYP = "kb+jwt";
+const encodePathSegment = (segment) => segment.replace(/~/g, "~0").replace(/\./g, "~1");
+const encodePath = (segments) => segments.map(encodePathSegment).join(".");
+const IANA_HASH_ALGORITHMS = [
+	"sha-256",
+	"sha-256-128",
+	"sha-256-120",
+	"sha-256-96",
+	"sha-256-64",
+	"sha-256-32",
+	"sha-384",
+	"sha-512",
+	"sha3-224",
+	"sha3-256",
+	"sha3-384",
+	"sha3-512",
+	"blake2s-256",
+	"blake2b-256",
+	"blake2b-512",
+	"k12-256",
+	"k12-512"
+];
+const DEFAULT_SECURE_HASH_ALGORITHMS = [
+	"sha-256",
+	"sha-384",
+	"sha-512",
+	"sha3-256",
+	"sha3-384",
+	"sha3-512",
+	"blake2s-256",
+	"blake2b-256",
+	"blake2b-512",
+	"k12-256",
+	"k12-512"
+];
+//#endregion
+//#region src/utils/error.ts
+var SDJWTException = class SDJWTException extends Error {
+	constructor(message, details) {
+		super(message);
+		Object.setPrototypeOf(this, SDJWTException.prototype);
+		this.name = "SDJWTException";
+		this.details = details;
+	}
+	getFullMessage() {
+		return `${this.name}: ${this.message} ${this.details ? `- ${JSON.stringify(this.details)}` : ""}`;
+	}
+};
+/**
+* Narrows an unknown caught value to an Error instance.
+*/
+function ensureError(value) {
+	if (value instanceof Error) return value;
+	if (typeof value === "string") return new Error(value);
+	return new Error(String(value));
+}
+//#endregion
+//#region src/utils/strict-json.ts
+/**
+* Decode base64url encoded JSON with {@link base64urlDecodeJson}, rethrowing failures as an
+* `SDJWTException` with the given message.
+*/
+const decodeBase64urlJsonStrict = (encoded, errorMessage) => {
+	try {
+		return (0, _owf_identity_common.base64urlDecodeJson)(encoded);
+	} catch {
+		throw new SDJWTException(errorMessage);
+	}
+};
+//#endregion
+//#region src/utils/disclosure.ts
+var Disclosure = class Disclosure {
+	constructor(data, _meta) {
+		if (!Array.isArray(data) || data.length !== 2 && data.length !== 3) throw new SDJWTException("Invalid disclosure data");
+		if (typeof data[0] !== "string") throw new SDJWTException("Invalid disclosure salt");
+		this._digest = _meta?.digest;
+		this._encoded = _meta?.encoded;
+		if (data.length === 2) {
+			this.salt = data[0];
+			this.value = data[1];
+			return;
+		}
+		if (data.length === 3) {
+			if (typeof data[1] !== "string") throw new SDJWTException("Invalid disclosure claim name");
+			if (data[1] === "_sd" || data[1] === "...") throw new SDJWTException(`Reserved disclosure claim name "${data[1]}" is not allowed`);
+			this.salt = data[0];
+			this.key = data[1];
+			this.value = data[2];
+			return;
+		}
+	}
+	static async fromEncode(s, hash) {
+		const { hasher, alg } = hash;
+		const digest = await hasher(s, alg);
+		const digestStr = (0, _owf_identity_common.uint8ArrayToBase64Url)(digest);
+		const item = decodeBase64urlJsonStrict(s, "Invalid disclosure data");
+		return Disclosure.fromArray(item, {
+			digest: digestStr,
+			encoded: s
+		});
+	}
+	static fromEncodeSync(s, hash) {
+		const { hasher, alg } = hash;
+		const digest = hasher(s, alg);
+		const digestStr = (0, _owf_identity_common.uint8ArrayToBase64Url)(digest);
+		const item = decodeBase64urlJsonStrict(s, "Invalid disclosure data");
+		return Disclosure.fromArray(item, {
+			digest: digestStr,
+			encoded: s
+		});
+	}
+	static fromArray(item, _meta) {
+		return new Disclosure(item, _meta);
+	}
+	encode() {
+		if (!this._encoded) this._encoded = (0, _owf_identity_common.base64urlEncode)(JSON.stringify(this.decode()));
+		return this._encoded;
+	}
+	decode() {
+		return this.key ? [
+			this.salt,
+			this.key,
+			this.value
+		] : [this.salt, this.value];
+	}
+	async digest(hash) {
+		const { hasher, alg } = hash;
+		if (!this._digest) {
+			const hash = await hasher(this.encode(), alg);
+			this._digest = (0, _owf_identity_common.uint8ArrayToBase64Url)(hash);
+		}
+		return this._digest;
+	}
+	digestSync(hash) {
+		const { hasher, alg } = hash;
+		if (!this._digest) {
+			const hash = hasher(this.encode(), alg);
+			this._digest = (0, _owf_identity_common.uint8ArrayToBase64Url)(hash);
+		}
+		return this._digest;
+	}
+};
+//#endregion
+//#region src/decode/decode.ts
+/**
+* Decode a JWT with `decodeJwt` from `@owf/identity-common`, rethrowing failures as an `SDJWTException`.
+*/
+const decodeJwt = (jwt) => {
+	try {
+		return (0, _owf_identity_common.decodeJwt)(jwt);
+	} catch {
+		throw new SDJWTException("Invalid JWT as input");
+	}
+};
+const splitSdJwt = (sdjwt) => {
+	const [encodedJwt, ...encodedDisclosures] = sdjwt.split("~");
+	if (encodedDisclosures.length === 0) throw new SDJWTException("Invalid SD-JWT: missing SD-JWT separator");
+	return {
+		jwt: encodedJwt,
+		disclosures: encodedDisclosures,
+		kbJwt: encodedDisclosures.pop() || void 0
+	};
+};
+const decodeSdJwt = async (sdjwt, hasher) => {
+	const [encodedJwt, ...encodedDisclosures] = sdjwt.split("~");
+	const jwt = decodeJwt(encodedJwt);
+	if (encodedDisclosures.length === 0) throw new SDJWTException("Invalid SD-JWT: missing SD-JWT separator");
+	const encodedKeyBindingJwt = encodedDisclosures.pop();
+	const kbJwt = encodedKeyBindingJwt ? decodeJwt(encodedKeyBindingJwt) : void 0;
+	const { _sd_alg } = getSDAlgAndPayload(jwt.payload);
+	return {
+		jwt,
+		disclosures: await Promise.all(encodedDisclosures.map((ed) => Disclosure.fromEncode(ed, {
+			alg: _sd_alg,
+			hasher
+		}))),
+		kbJwt
+	};
+};
+const decodeSdJwtSync = (sdjwt, hasher) => {
+	const [encodedJwt, ...encodedDisclosures] = sdjwt.split("~");
+	const jwt = decodeJwt(encodedJwt);
+	if (encodedDisclosures.length === 0) throw new SDJWTException("Invalid SD-JWT: missing SD-JWT separator");
+	const encodedKeyBindingJwt = encodedDisclosures.pop();
+	const kbJwt = encodedKeyBindingJwt ? decodeJwt(encodedKeyBindingJwt) : void 0;
+	const { _sd_alg } = getSDAlgAndPayload(jwt.payload);
+	return {
+		jwt,
+		disclosures: encodedDisclosures.map((ed) => Disclosure.fromEncodeSync(ed, {
+			alg: _sd_alg,
+			hasher
+		})),
+		kbJwt
+	};
+};
+const getClaims = async (rawPayload, disclosures, hasher) => {
+	const { unpackedObj } = await unpack(rawPayload, disclosures, hasher);
+	return unpackedObj;
+};
+const getClaimsSync = (rawPayload, disclosures, hasher) => {
+	const { unpackedObj } = unpackSync(rawPayload, disclosures, hasher);
+	return unpackedObj;
+};
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const unpackArray = (arr, map, prefix = "", seenDigests) => {
+	const keys = {};
+	const unpackedArray = [];
+	arr.forEach((item, idx) => {
+		if (isRecord(item)) {
+			const hash = item["..."];
+			if ("..." in item) {
+				if (Object.keys(item).length !== 1 || typeof hash !== "string") throw new SDJWTException("Invalid array disclosure placeholder");
+				if (seenDigests) {
+					if (seenDigests.has(hash)) throw new SDJWTException("Duplicate digest found in SD-JWT payload");
+					seenDigests.add(hash);
+				}
+				const disclosed = map[hash];
+				if (disclosed) {
+					if (typeof disclosed.key === "string") throw new SDJWTException("Object-property disclosure cannot be used as an array element");
+					const presentKey = prefix ? `${prefix}.${idx}` : `${idx}`;
+					keys[presentKey] = hash;
+					const { unpackedObj, disclosureKeymap: disclosureKeys } = unpackObjInternal(disclosed.value, map, presentKey, seenDigests);
+					unpackedArray.push(unpackedObj);
+					Object.assign(keys, disclosureKeys);
+				}
+			} else {
+				const newKey = prefix ? `${prefix}.${idx}` : `${idx}`;
+				const { unpackedObj, disclosureKeymap: disclosureKeys } = unpackObjInternal(item, map, newKey, seenDigests);
+				unpackedArray.push(unpackedObj);
+				Object.assign(keys, disclosureKeys);
+			}
+		} else if (Array.isArray(item)) {
+			const newKey = prefix ? `${prefix}.${idx}` : `${idx}`;
+			const { unpackedObj, disclosureKeymap: disclosureKeys } = unpackObjInternal(item, map, newKey, seenDigests);
+			unpackedArray.push(unpackedObj);
+			Object.assign(keys, disclosureKeys);
+		} else unpackedArray.push(item);
+	});
+	return {
+		unpackedObj: unpackedArray,
+		disclosureKeymap: keys
+	};
+};
+const unpackObj = (obj, map) => {
+	const copiedObj = JSON.parse(JSON.stringify(obj));
+	const seenDigests = /* @__PURE__ */ new Set();
+	const result = unpackObjInternal(copiedObj, map, "", seenDigests);
+	if (Object.keys(map).filter((d) => !seenDigests.has(d)).length > 0) throw new SDJWTException("Unreferenced disclosure(s) detected in SD-JWT");
+	return result;
+};
+const unpackObjInternal = (obj, map, prefix = "", seenDigests) => {
+	const keys = {};
+	if (typeof obj === "object" && obj !== null) {
+		if (Array.isArray(obj)) return unpackArray(obj, map, prefix, seenDigests);
+		const record = obj;
+		for (const key in record) {
+			if (prefix && key === "_sd_alg") throw new SDJWTException("Nested _sd_alg is not allowed");
+			if (key !== "_sd" && key !== "..." && typeof record[key] === "object") {
+				const escapedKey = encodePathSegment(key);
+				const newKey = prefix ? `${prefix}.${escapedKey}` : escapedKey;
+				const { unpackedObj, disclosureKeymap: disclosureKeys } = unpackObjInternal(record[key], map, newKey, seenDigests);
+				record[key] = unpackedObj;
+				Object.assign(keys, disclosureKeys);
+			}
+		}
+		const { _sd, ...payload } = record;
+		const claims = {};
+		if (_sd !== void 0) {
+			if (!Array.isArray(_sd) || !_sd.every((hash) => typeof hash === "string")) throw new SDJWTException("Invalid _sd claim: expected array of strings");
+			for (const hash of _sd) {
+				if (seenDigests) {
+					if (seenDigests.has(hash)) throw new SDJWTException("Duplicate digest found in SD-JWT payload");
+					seenDigests.add(hash);
+				}
+				const disclosed = map[hash];
+				if (disclosed) {
+					if (typeof disclosed.key !== "string") throw new SDJWTException("Array disclosure cannot be used as an object property");
+					if (disclosed.key in payload) throw new SDJWTException(`Disclosed claim name "${disclosed.key}" conflicts with existing payload key`);
+					if (disclosed.key in claims) throw new SDJWTException(`Disclosed claim name "${disclosed.key}" conflicts with another disclosure`);
+					const escapedKey = encodePathSegment(disclosed.key);
+					const presentKey = prefix ? `${prefix}.${escapedKey}` : escapedKey;
+					keys[presentKey] = hash;
+					const { unpackedObj, disclosureKeymap: disclosureKeys } = unpackObjInternal(disclosed.value, map, presentKey, seenDigests);
+					claims[disclosed.key] = unpackedObj;
+					Object.assign(keys, disclosureKeys);
+				}
+			}
+		}
+		return {
+			unpackedObj: Object.assign(payload, claims),
+			disclosureKeymap: keys
+		};
+	}
+	return {
+		unpackedObj: obj,
+		disclosureKeymap: keys
+	};
+};
+const createHashMapping = async (disclosures, hash) => {
+	const map = {};
+	for (let i = 0; i < disclosures.length; i++) {
+		const disclosure = disclosures[i];
+		const digest = await disclosure.digest(hash);
+		if (digest in map) throw new SDJWTException("Duplicate disclosure digest detected");
+		map[digest] = disclosure;
+	}
+	return map;
+};
+const createHashMappingSync = (disclosures, hash) => {
+	const map = {};
+	for (let i = 0; i < disclosures.length; i++) {
+		const disclosure = disclosures[i];
+		const digest = disclosure.digestSync(hash);
+		if (digest in map) throw new SDJWTException("Duplicate disclosure digest detected");
+		map[digest] = disclosure;
+	}
+	return map;
+};
+const getSDAlgAndPayload = (SdJwtPayload, allowedAlgorithms = DEFAULT_SECURE_HASH_ALGORITHMS) => {
+	const { _sd_alg, ...payload } = SdJwtPayload;
+	if (_sd_alg === void 0) return {
+		_sd_alg: "sha-256",
+		payload
+	};
+	if (typeof _sd_alg !== "string") throw new SDJWTException("Invalid _sd_alg: expected string");
+	if (!IANA_HASH_ALGORITHMS.includes(_sd_alg)) throw new SDJWTException(`Invalid _sd_alg: ${_sd_alg}`);
+	if (!allowedAlgorithms.includes(_sd_alg)) throw new SDJWTException(`Disallowed _sd_alg: ${_sd_alg}`);
+	return {
+		_sd_alg,
+		payload
+	};
+};
+const unpack = async (SdJwtPayload, disclosures, hasher) => {
+	const { _sd_alg, payload } = getSDAlgAndPayload(SdJwtPayload);
+	const map = await createHashMapping(disclosures, {
+		hasher,
+		alg: _sd_alg
+	});
+	return unpackObj(payload, map);
+};
+const unpackSync = (SdJwtPayload, disclosures, hasher) => {
+	const { _sd_alg, payload } = getSDAlgAndPayload(SdJwtPayload);
+	const map = createHashMappingSync(disclosures, {
+		hasher,
+		alg: _sd_alg
+	});
+	return unpackObj(payload, map);
+};
+//#endregion
+//#region src/flattenJSON.ts
+var FlattenJSON = class FlattenJSON {
+	constructor(data) {
+		this.disclosures = data.disclosures;
+		this.kb_jwt = data.kb_jwt;
+		this.payload = data.jwtData.payload;
+		this.signature = data.jwtData.signature;
+		this.protected = data.jwtData.protected;
+	}
+	static fromEncode(encodedSdJwt) {
+		const { jwt, disclosures, kbJwt } = splitSdJwt(encodedSdJwt);
+		const { 0: protectedHeader, 1: payload, 2: signature } = jwt.split(".");
+		if (!protectedHeader || !payload || !signature) throw new SDJWTException("Invalid JWT");
+		return new FlattenJSON({
+			jwtData: {
+				protected: protectedHeader,
+				payload,
+				signature
+			},
+			disclosures,
+			kb_jwt: kbJwt
+		});
+	}
+	static fromSerialized(json) {
+		return new FlattenJSON({
+			jwtData: {
+				protected: json.protected,
+				payload: json.payload,
+				signature: json.signature
+			},
+			disclosures: json.header.disclosures,
+			kb_jwt: json.header.kb_jwt
+		});
+	}
+	toJson() {
+		return {
+			payload: this.payload,
+			signature: this.signature,
+			protected: this.protected,
+			header: {
+				disclosures: this.disclosures,
+				kb_jwt: this.kb_jwt
+			}
+		};
+	}
+	toEncoded() {
+		const data = [];
+		const jwt = `${this.protected}.${this.payload}.${this.signature}`;
+		data.push(jwt);
+		if (this.disclosures && this.disclosures.length > 0) {
+			const disclosures = this.disclosures.join("~");
+			data.push(disclosures);
+		}
+		const kb_jwt = this.kb_jwt ?? "";
+		data.push(kb_jwt);
+		return data.join("~");
+	}
+};
+//#endregion
+//#region src/generalJSON.ts
+var GeneralJSON = class GeneralJSON {
+	constructor(data) {
+		this.payload = data.payload;
+		this.disclosures = data.disclosures;
+		this.kb_jwt = data.kb_jwt;
+		this.signatures = data.signatures;
+	}
+	static fromEncode(encodedSdJwt) {
+		const { jwt, disclosures, kbJwt } = splitSdJwt(encodedSdJwt);
+		const { 0: protectedHeader, 1: payload, 2: signature } = jwt.split(".");
+		if (!protectedHeader || !payload || !signature) throw new SDJWTException("Invalid JWT");
+		return new GeneralJSON({
+			payload,
+			disclosures,
+			kb_jwt: kbJwt,
+			signatures: [{
+				protected: protectedHeader,
+				signature
+			}]
+		});
+	}
+	static fromSerialized(json) {
+		if (!json.signatures[0]) throw new SDJWTException("Invalid JSON");
+		for (let index = 1; index < json.signatures.length; index++) {
+			const header = json.signatures[index].header;
+			if (header && ("disclosures" in header || "kb_jwt" in header)) throw new SDJWTException("disclosures and kb_jwt MUST only appear in the first unprotected header");
+		}
+		const disclosures = json.signatures[0].header?.disclosures ?? [];
+		const kb_jwt = json.signatures[0].header?.kb_jwt;
+		return new GeneralJSON({
+			payload: json.payload,
+			disclosures,
+			kb_jwt,
+			signatures: json.signatures.map((s) => {
+				return {
+					protected: s.protected,
+					signature: s.signature,
+					kid: s.header?.kid
+				};
+			})
+		});
+	}
+	toJson() {
+		return {
+			payload: this.payload,
+			signatures: this.signatures.map((s, i) => {
+				if (i !== 0) return {
+					header: { kid: s.kid },
+					protected: s.protected,
+					signature: s.signature
+				};
+				return {
+					header: {
+						disclosures: this.disclosures,
+						kid: s.kid,
+						kb_jwt: this.kb_jwt
+					},
+					protected: s.protected,
+					signature: s.signature
+				};
+			})
+		};
+	}
+	toEncoded(index) {
+		if (index < 0 || index >= this.signatures.length) throw new SDJWTException("Index out of bounds");
+		const data = [];
+		const { protected: protectedHeader, signature } = this.signatures[index];
+		const jwt = `${protectedHeader}.${this.payload}.${signature}`;
+		data.push(jwt);
+		if (this.disclosures && this.disclosures.length > 0) {
+			const disclosures = this.disclosures.join("~");
+			data.push(disclosures);
+		}
+		const kb = this.kb_jwt ?? "";
+		data.push(kb);
+		return data.join("~");
+	}
+	async addSignature(protectedHeader, signer, kid) {
+		const header = (0, _owf_identity_common.base64urlEncode)(JSON.stringify(protectedHeader));
+		const signature = await signer(`${header}.${this.payload}`);
+		this.signatures.push({
+			protected: header,
+			signature,
+			kid
+		});
+	}
+};
+//#endregion
+//#region src/jwt.ts
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+const validateNumericDate = (payload, claim) => {
+	const value = payload[claim];
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new SDJWTException(`Verify Error: JWT ${claim} must be a number`);
+	return value;
+};
+const getAudiences = (audience) => {
+	if (typeof audience === "string") return [audience];
+	if (isStringArray(audience)) return audience;
+};
+const validateAudience = (payload, expectedAudience) => {
+	if (expectedAudience === void 0) return;
+	const expectedAudiences = Array.isArray(expectedAudience) ? expectedAudience : [expectedAudience];
+	const audiences = getAudiences(payload.aud);
+	if (!audiences || !expectedAudiences.some((expected) => audiences.includes(expected))) throw new SDJWTException("Verify Error: Invalid audience");
+};
+const validateJwtPayload = (payload, options) => {
+	if (!payload) throw new SDJWTException("Verify Error: JWT payload is missing");
+	const skew = options?.skewSeconds ? options.skewSeconds : 0;
+	const currentDate = options?.currentDate ?? (0, _owf_identity_common.nowInSeconds)();
+	const iat = validateNumericDate(payload, "iat");
+	const nbf = validateNumericDate(payload, "nbf");
+	const exp = validateNumericDate(payload, "exp");
+	if (iat !== void 0 && iat - skew > currentDate) throw new SDJWTException("Verify Error: JWT is not yet valid");
+	if (nbf !== void 0 && nbf - skew > currentDate) throw new SDJWTException("Verify Error: JWT is not yet valid");
+	if (exp !== void 0 && exp + skew <= currentDate) throw new SDJWTException("Verify Error: JWT is expired");
+	validateAudience(payload, options?.expectedAudience);
+};
+var Jwt = class Jwt {
+	constructor(data) {
+		this.header = data?.header;
+		this.payload = data?.payload;
+		this.signature = data?.signature;
+		this.encoded = data?.encoded;
+	}
+	static decodeJWT(jwt) {
+		return decodeJwt(jwt);
+	}
+	static fromEncode(encodedJwt) {
+		const { header, payload, signature } = Jwt.decodeJWT(encodedJwt);
+		return new Jwt({
+			header,
+			payload,
+			signature,
+			encoded: encodedJwt
+		});
+	}
+	setHeader(header) {
+		this.header = header;
+		this.encoded = void 0;
+		return this;
+	}
+	setPayload(payload) {
+		this.payload = payload;
+		this.encoded = void 0;
+		return this;
+	}
+	getUnsignedToken() {
+		if (!this.header || !this.payload) throw new SDJWTException("Serialize Error: Invalid JWT");
+		if (this.encoded) {
+			const parts = this.encoded.split(".");
+			if (parts.length !== 3) throw new SDJWTException(`Invalid JWT format: ${this.encoded}`);
+			return parts.slice(0, 2).join(".");
+		}
+		return `${(0, _owf_identity_common.base64urlEncode)(JSON.stringify(this.header))}.${(0, _owf_identity_common.base64urlEncode)(JSON.stringify(this.payload))}`;
+	}
+	async sign(signer) {
+		if (!this.header || this.header.alg === "none") throw new SDJWTException("Sign Error: alg \"none\" is not allowed");
+		const data = this.getUnsignedToken();
+		this.signature = await signer(data);
+		return this.encodeJwt();
+	}
+	encodeJwt() {
+		if (this.encoded) return this.encoded;
+		if (!this.header || !this.payload || !this.signature) throw new SDJWTException("Serialize Error: Invalid JWT");
+		const compact = `${(0, _owf_identity_common.base64urlEncode)(JSON.stringify(this.header))}.${(0, _owf_identity_common.base64urlEncode)(JSON.stringify(this.payload))}.${this.signature}`;
+		this.encoded = compact;
+		return compact;
+	}
+	/**
+	* Verify the JWT using the provided verifier function.
+	* It checks the signature and validates the iat, nbf, and exp claims if they are present.
+	* @param verifier
+	* @param options - Options for verification, such as current date and skew seconds
+	* @returns
+	*/
+	async verify(verifier, options) {
+		const alg = this.header?.alg;
+		if (typeof alg !== "string" || alg === "none") throw new SDJWTException("Verify Error: alg \"none\" is not allowed");
+		if (options?.allowedIssuerAlgorithms && !options.allowedIssuerAlgorithms.includes(alg)) throw new SDJWTException(`Verify Error: Disallowed alg ${alg}`);
+		if (!options?.skipJwtClaimValidation) validateJwtPayload(this.payload, options);
+		if (!this.signature) throw new SDJWTException("Verify Error: no signature in JWT");
+		if (!await verifier(this.getUnsignedToken(), this.signature, options)) throw new SDJWTException("Verify Error: Invalid JWT Signature");
+		return {
+			payload: this.payload,
+			header: this.header
+		};
+	}
+};
+//#endregion
+//#region src/kbjwt.ts
+var KBJwt = class KBJwt extends Jwt {
+	async verifyKB(values) {
+		if (!this.header || !this.payload || !this.signature) throw new SDJWTException("Verify Error: Invalid JWT");
+		if (typeof this.header.alg !== "string" || this.header.alg === "none" || typeof this.header.typ !== "string" || this.header.typ !== "kb+jwt" || typeof this.payload.iat !== "number" || typeof this.payload.aud !== "string" || typeof this.payload.nonce !== "string" || typeof this.payload.sd_hash !== "string" || this.payload.sd_hash.length === 0) throw new SDJWTException("Invalid Key Binding Jwt");
+		if (this.payload.nonce !== values.nonce) throw new SDJWTException("Verify Error: Invalid Nonce");
+		if (values.options?.expectedKeyBindingAudience !== void 0) {
+			if (!(Array.isArray(values.options.expectedKeyBindingAudience) ? values.options.expectedKeyBindingAudience : [values.options.expectedKeyBindingAudience]).includes(this.payload.aud)) throw new SDJWTException("Verify Error: Invalid Key Binding audience");
+		}
+		if (values.options?.keyBindingMaxAgeSeconds !== void 0) {
+			const currentDate = values.options.currentDate ?? (0, _owf_identity_common.nowInSeconds)();
+			const skew = values.options.skewSeconds ?? 0;
+			if (this.payload.iat + values.options.keyBindingMaxAgeSeconds + skew < currentDate) throw new SDJWTException("Verify Error: Key Binding JWT is too old");
+		}
+		await this.verify((data, sig) => values.verifier(data, sig, values.payload), values.options);
+		return {
+			payload: this.payload,
+			header: this.header
+		};
+	}
+	static fromKBEncode(encodedJwt) {
+		const { header, payload, signature } = Jwt.decodeJWT(encodedJwt);
+		return new KBJwt({
+			header,
+			payload,
+			signature,
+			encoded: encodedJwt
+		});
+	}
+};
+//#endregion
+//#region src/decoy.ts
+const createDecoy = async (hash, saltGenerator) => {
+	const { hasher, alg } = hash;
+	const decoy = await hasher(await saltGenerator(16), alg);
+	return (0, _owf_identity_common.uint8ArrayToBase64Url)(decoy);
+};
+//#endregion
+//#region src/present/present.ts
+const presentableKeys = async (rawPayload, disclosures, hasher) => {
+	const { disclosureKeymap } = await unpack(rawPayload, disclosures, hasher);
+	return Object.keys(disclosureKeymap).sort();
+};
+const presentableKeysSync = (rawPayload, disclosures, hasher) => {
+	const { disclosureKeymap } = unpackSync(rawPayload, disclosures, hasher);
+	return Object.keys(disclosureKeymap).sort();
+};
+const present = async (sdJwt, presentFrame, hasher) => {
+	const { jwt, kbJwt } = splitSdJwt(sdJwt);
+	const { jwt: { payload }, disclosures } = await decodeSdJwt(sdJwt, hasher);
+	const { _sd_alg: alg } = getSDAlgAndPayload(payload);
+	const hash = {
+		alg,
+		hasher
+	};
+	const keys = transformPresentationFrame(presentFrame);
+	const hashmap = await createHashMapping(disclosures, hash);
+	const { disclosureKeymap } = await unpack(payload, disclosures, hasher);
+	return [
+		jwt,
+		...keys.map((k) => hashmap[disclosureKeymap[k]]).filter((d) => d !== void 0).map((d) => d.encode()),
+		kbJwt ?? ""
+	].join("~");
+};
+const presentSync = (sdJwt, presentFrame, hasher) => {
+	const { jwt, kbJwt } = splitSdJwt(sdJwt);
+	const { jwt: { payload }, disclosures } = decodeSdJwtSync(sdJwt, hasher);
+	const { _sd_alg: alg } = getSDAlgAndPayload(payload);
+	const hash = {
+		alg,
+		hasher
+	};
+	const keys = transformPresentationFrame(presentFrame);
+	const hashmap = createHashMappingSync(disclosures, hash);
+	const { disclosureKeymap } = unpackSync(payload, disclosures, hasher);
+	return [
+		jwt,
+		...keys.map((k) => hashmap[disclosureKeymap[k]]).filter((d) => d !== void 0).map((d) => d.encode()),
+		kbJwt ?? ""
+	].join("~");
+};
+/**
+* Transform the object keys into an array of strings. We are not sorting the array in any way.
+* @param obj The object to transform
+* @param prefix The prefix to add to the keys
+* @returns
+*/
+const transformPresentationFrame = (obj, prefix = []) => {
+	return Object.entries(obj).reduce((acc, [key, value]) => {
+		const newPrefix = [...prefix, key];
+		const encodedPrefix = encodePath(newPrefix);
+		if (typeof value === "boolean") {
+			if (value) acc.push(encodedPrefix);
+		} else if (typeof value === "object" && value !== null) acc.push(encodedPrefix, ...transformPresentationFrame(value, newPrefix));
+		return acc;
+	}, []);
+};
+const createHashMappingForSerializedDisclosure = (disclosures) => {
+	const map = {};
+	for (let i = 0; i < disclosures.length; i++) {
+		const { digest, encoded, key, salt, value } = disclosures[i];
+		map[digest] = Disclosure.fromArray(key ? [
+			salt,
+			key,
+			value
+		] : [salt, value], {
+			digest,
+			encoded
+		});
+	}
+	return map;
+};
+/**
+* This function selects the serialized disclosures from the payload
+* and array of serialized disclosure based on the presentation frame.
+* If you want to know what is serialized disclosures, check type SerializedDisclosure.
+* @param payload: Record<string, unknown>
+* @param disclosures: SerializedDisclosure[]
+* @param presentationFrame: PresentationFrame<T>
+*/
+const selectDisclosures = (payload, disclosures, presentationFrame) => {
+	if (disclosures.length === 0) return [];
+	const hashmap = createHashMappingForSerializedDisclosure(disclosures);
+	const { disclosureKeymap } = unpackObj(payload, hashmap);
+	return transformPresentationFrame(presentationFrame).map((k) => hashmap[disclosureKeymap[k]]).filter((d) => d !== void 0).map((d) => {
+		const { salt, key, value, _digest } = d;
+		if (!_digest) throw new SDJWTException("Implementation error: _digest is not defined");
+		return {
+			digest: _digest,
+			encoded: d.encode(),
+			salt,
+			key,
+			value
+		};
+	});
+};
+//#endregion
+//#region src/sdjwt.ts
+const createDisclosureSalt = async (saltGenerator, seenSalts) => {
+	const salt = await saltGenerator(16);
+	if (typeof salt !== "string") throw new SDJWTException("SaltGenerator must return a string");
+	if (seenSalts.has(salt)) throw new SDJWTException("Duplicate disclosure salt detected");
+	seenSalts.add(salt);
+	return salt;
+};
+const addDisclosureDigest = (digest, seenDigests) => {
+	if (seenDigests.has(digest)) throw new SDJWTException("Duplicate disclosure digest detected");
+	seenDigests.add(digest);
+};
+var SDJwt = class SDJwt {
+	constructor(data) {
+		this.jwt = data?.jwt;
+		this.disclosures = data?.disclosures;
+		this.kbJwt = data?.kbJwt;
+	}
+	static async decodeSDJwt(sdjwt, hasher) {
+		const [encodedJwt, ...encodedDisclosures] = sdjwt.split("~");
+		if (encodedDisclosures.length === 0) throw new SDJWTException("Invalid SD-JWT: missing SD-JWT separator");
+		const jwt = Jwt.fromEncode(encodedJwt);
+		if (!jwt.payload) throw new Error("Payload is undefined on the JWT. Invalid state reached");
+		const encodedKeyBindingJwt = encodedDisclosures.pop();
+		const kbJwt = encodedKeyBindingJwt ? KBJwt.fromKBEncode(encodedKeyBindingJwt) : void 0;
+		const { _sd_alg } = getSDAlgAndPayload(jwt.payload);
+		return {
+			jwt,
+			disclosures: await Promise.all(encodedDisclosures.map((ed) => Disclosure.fromEncode(ed, {
+				alg: _sd_alg,
+				hasher
+			}))),
+			kbJwt
+		};
+	}
+	static async extractJwt(encodedSdJwt) {
+		const [encodedJwt, ..._encodedDisclosures] = encodedSdJwt.split("~");
+		return Jwt.fromEncode(encodedJwt);
+	}
+	static async fromEncode(encodedSdJwt, hasher) {
+		const { jwt, disclosures, kbJwt } = await SDJwt.decodeSDJwt(encodedSdJwt, hasher);
+		return new SDJwt({
+			jwt,
+			disclosures,
+			kbJwt
+		});
+	}
+	async present(presentFrame, hasher) {
+		const disclosures = await this.getPresentDisclosures(presentFrame, hasher);
+		return new SDJwt({
+			jwt: this.jwt,
+			disclosures,
+			kbJwt: this.kbJwt
+		}).encodeSDJwt();
+	}
+	async getPresentDisclosures(presentFrame, hasher) {
+		if (!this.jwt?.payload || !this.disclosures) throw new SDJWTException("Invalid sd-jwt: jwt or disclosures is missing");
+		const { _sd_alg: alg } = getSDAlgAndPayload(this.jwt.payload);
+		const hash = {
+			alg,
+			hasher
+		};
+		const hashmap = await createHashMapping(this.disclosures, hash);
+		const { disclosureKeymap } = await unpack(this.jwt.payload, this.disclosures, hasher);
+		return (presentFrame ? transformPresentationFrame(presentFrame) : await this.presentableKeys(hasher)).map((k) => hashmap[disclosureKeymap[k]]).filter((d) => d !== void 0);
+	}
+	encodeSDJwt() {
+		const data = [];
+		if (!this.jwt) throw new SDJWTException("Invalid sd-jwt: jwt is missing");
+		const encodedJwt = this.jwt.encodeJwt();
+		data.push(encodedJwt);
+		if (this.disclosures && this.disclosures.length > 0) {
+			const encodeddisclosures = this.disclosures.map((dc) => dc.encode()).join("~");
+			data.push(encodeddisclosures);
+		}
+		data.push(this.kbJwt ? this.kbJwt.encodeJwt() : "");
+		return data.join("~");
+	}
+	async keys(hasher) {
+		return listKeys(await this.getClaims(hasher)).sort();
+	}
+	async presentableKeys(hasher) {
+		if (!this.jwt?.payload || !this.disclosures) throw new SDJWTException("Invalid sd-jwt: jwt or disclosures is missing");
+		const { disclosureKeymap } = await unpack(this.jwt?.payload, this.disclosures, hasher);
+		return Object.keys(disclosureKeymap).sort();
+	}
+	async getClaims(hasher) {
+		if (!this.jwt?.payload || !this.disclosures) throw new SDJWTException("Invalid sd-jwt: jwt or disclosures is missing");
+		const { unpackedObj } = await unpack(this.jwt.payload, this.disclosures, hasher);
+		return unpackedObj;
+	}
+};
+const listKeys = (obj, prefix = "") => {
+	const keys = [];
+	for (const key in obj) {
+		if (obj[key] === void 0) continue;
+		const escapedKey = encodePathSegment(key);
+		const newKey = prefix ? `${prefix}.${escapedKey}` : escapedKey;
+		keys.push(newKey);
+		const value = obj[key];
+		if (value && typeof value === "object") keys.push(...listKeys(value, newKey));
+	}
+	return keys;
+};
+const pack = async (claims, disclosureFrame, hash, saltGenerator, seenSalts = /* @__PURE__ */ new Set(), seenDigests = /* @__PURE__ */ new Set()) => {
+	if (!disclosureFrame) return {
+		packedClaims: claims,
+		disclosures: []
+	};
+	const sd = disclosureFrame["_sd"] ?? [];
+	const decoyCount = disclosureFrame["_sd_decoy"] ?? 0;
+	if (Array.isArray(claims)) {
+		const packedClaims = [];
+		const disclosures = [];
+		const recursivePackedClaims = {};
+		for (const key in disclosureFrame) if (key !== "_sd") {
+			const idx = Number.parseInt(key, 10);
+			const packed = await pack(claims[idx], disclosureFrame[idx], hash, saltGenerator, seenSalts, seenDigests);
+			recursivePackedClaims[idx] = packed.packedClaims;
+			disclosures.push(...packed.disclosures);
+		}
+		for (let i = 0; i < claims.length; i++) {
+			const claim = recursivePackedClaims[i] ? recursivePackedClaims[i] : claims[i];
+			/** This part is set discloure for array items.
+			*  The example of disclosureFrame of an Array is
+			*
+			*  const claims = {
+			*    array: ['a', 'b', 'c']
+			*  }
+			*
+			*  diclosureFrame: DisclosureFrame<typeof claims> = {
+			*    array: {
+			*      _sd: [0, 2]
+			*    }
+			*  }
+			*
+			*  It means that we want to disclose the first and the third item of the array
+			*
+			*  So If the index `i` is in the disclosure list(sd), then we create a disclosure for the claim
+			*/
+			if (sd.includes(i)) {
+				const disclosure = new Disclosure([await createDisclosureSalt(saltGenerator, seenSalts), claim]);
+				const digest = await disclosure.digest(hash);
+				addDisclosureDigest(digest, seenDigests);
+				packedClaims.push({ ["..."]: digest });
+				disclosures.push(disclosure);
+			} else packedClaims.push(claim);
+		}
+		for (let j = 0; j < decoyCount; j++) {
+			const decoyDigest = await createDecoy(hash, saltGenerator);
+			addDisclosureDigest(decoyDigest, seenDigests);
+			packedClaims.push({ ["..."]: decoyDigest });
+		}
+		return {
+			packedClaims,
+			disclosures
+		};
+	}
+	const packedClaims = {};
+	const disclosures = [];
+	const recursivePackedClaims = {};
+	for (const key in disclosureFrame) if (key !== "_sd") {
+		const packed = await pack(claims[key], disclosureFrame[key], hash, saltGenerator, seenSalts, seenDigests);
+		recursivePackedClaims[key] = packed.packedClaims;
+		disclosures.push(...packed.disclosures);
+	}
+	const _sd = [];
+	for (const key in claims) {
+		const claim = recursivePackedClaims[key] ? recursivePackedClaims[key] : claims[key];
+		if (sd.includes(key)) {
+			const disclosure = new Disclosure([
+				await createDisclosureSalt(saltGenerator, seenSalts),
+				key,
+				claim
+			]);
+			const digest = await disclosure.digest(hash);
+			addDisclosureDigest(digest, seenDigests);
+			_sd.push(digest);
+			disclosures.push(disclosure);
+		} else packedClaims[key] = claim;
+	}
+	for (let j = 0; j < decoyCount; j++) {
+		const decoyDigest = await createDecoy(hash, saltGenerator);
+		addDisclosureDigest(decoyDigest, seenDigests);
+		_sd.push(decoyDigest);
+	}
+	if (_sd.length > 0) packedClaims["_sd"] = _sd.sort();
+	return {
+		packedClaims,
+		disclosures
+	};
+};
+//#endregion
+//#region src/index.ts
+/**
+* Internal utility function to validate that a payload does not contain reserved field names.
+*/
+function validateReservedFieldsInternal(payload) {
+	const reservedFields = /* @__PURE__ */ new Set([
+		"_sd",
+		"_sd_alg",
+		SD_DECOY,
+		"..."
+	]);
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		for (const [key, value] of Object.entries(node)) {
+			if (reservedFields.has(key)) throw new SDJWTException(`Reserved field name "${key}" is not allowed`);
+			visit(value);
+		}
+	};
+	visit(payload);
+}
+var SDJwtInstance = class SDJwtInstance {
+	static {
+		this.DEFAULT_hashAlg = "sha-256";
+	}
+	constructor(userConfig) {
+		this.userConfig = {};
+		if (userConfig) {
+			if (userConfig.hashAlg && !IANA_HASH_ALGORITHMS.includes(userConfig.hashAlg)) throw new SDJWTException(`Invalid hash algorithm: ${userConfig.hashAlg}`);
+			const allowedDisclosureHashAlgorithms = userConfig.allowedDisclosureHashAlgorithms ?? DEFAULT_SECURE_HASH_ALGORITHMS;
+			if (userConfig.hashAlg && !allowedDisclosureHashAlgorithms.includes(userConfig.hashAlg)) throw new SDJWTException(`Disallowed hash algorithm: ${userConfig.hashAlg}`);
+			this.userConfig = userConfig;
+		}
+	}
+	async createKBJwt(options, sdHash) {
+		if (!this.userConfig.kbSigner) throw new SDJWTException("Key Binding Signer not found");
+		if (!this.userConfig.kbSignAlg) throw new SDJWTException("Key Binding sign algorithm not specified");
+		const { payload } = options;
+		const kbJwt = new KBJwt({
+			header: {
+				typ: KB_JWT_TYP,
+				alg: this.userConfig.kbSignAlg
+			},
+			payload: {
+				...payload,
+				sd_hash: sdHash
+			}
+		});
+		await kbJwt.sign(this.userConfig.kbSigner);
+		return kbJwt;
+	}
+	async SignJwt(jwt) {
+		if (!this.userConfig.signer) throw new SDJWTException("Signer not found");
+		await jwt.sign(this.userConfig.signer);
+		return jwt;
+	}
+	async VerifyJwt(jwt, options) {
+		if (!this.userConfig.verifier) throw new SDJWTException("Verifier not found");
+		return jwt.verify(this.userConfig.verifier, options);
+	}
+	async issue(payload, disclosureFrame, options) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		if (!this.userConfig.saltGenerator) throw new SDJWTException("SaltGenerator not found");
+		if (!this.userConfig.signAlg) throw new SDJWTException("sign alogrithm not specified");
+		if (this.userConfig.signAlg === "none") throw new SDJWTException("sign algorithm \"none\" is not allowed");
+		this.validateReservedFields(payload);
+		this.validateDisclosureFrame(disclosureFrame);
+		const hasher = this.userConfig.hasher;
+		const hashAlg = this.userConfig.hashAlg ?? SDJwtInstance.DEFAULT_hashAlg;
+		if (!(this.userConfig.allowedDisclosureHashAlgorithms ?? DEFAULT_SECURE_HASH_ALGORITHMS).includes(hashAlg)) throw new SDJWTException(`Disallowed hash algorithm: ${hashAlg}`);
+		const { packedClaims, disclosures } = await pack(payload, disclosureFrame, {
+			hasher,
+			alg: hashAlg
+		}, this.userConfig.saltGenerator);
+		const alg = this.userConfig.signAlg;
+		const OptionHeader = options?.header ?? {};
+		const jwt = new Jwt({
+			header: {
+				...this.userConfig.omitTyp ? OptionHeader : {
+					typ: this.type,
+					...OptionHeader
+				},
+				alg
+			},
+			payload: {
+				...packedClaims,
+				_sd_alg: disclosureFrame ? hashAlg : void 0
+			}
+		});
+		await this.SignJwt(jwt);
+		return new SDJwt({
+			jwt,
+			disclosures
+		}).encodeSDJwt();
+	}
+	/**
+	* Validates if the payload contains any reserved claim names. If so it will throw an error.
+	* @param payload
+	* @returns
+	*/
+	validateReservedFields(payload) {
+		validateReservedFieldsInternal(payload);
+	}
+	validateDisclosureFrame(_disclosureFrame) {}
+	async present(encodedSDJwt, presentationFrame, options) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		const hasher = this.userConfig.hasher;
+		const sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
+		if (sdjwt.kbJwt) throw new SDJWTException("Holder cannot present an SD-JWT with KB-JWT");
+		if (!sdjwt.jwt?.payload) throw new SDJWTException("Payload not found");
+		const presentSdJwtWithoutKb = await sdjwt.present(presentationFrame, hasher);
+		if (!options?.kb) return presentSdJwtWithoutKb;
+		const sdHashStr = await this.calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher);
+		sdjwt.kbJwt = await this.createKBJwt(options.kb, sdHashStr);
+		return sdjwt.present(presentationFrame, hasher);
+	}
+	async verify(encodedSDJwt, options) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		const hasher = this.userConfig.hasher;
+		const sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
+		if (!sdjwt.jwt?.payload) throw new SDJWTException("Invalid SD JWT");
+		const { payload, header } = await this.validate(encodedSDJwt, options);
+		if (options?.requiredClaimKeys) {
+			const keys = await sdjwt.keys(hasher);
+			const missingKeys = options.requiredClaimKeys.filter((k) => !keys.includes(k));
+			if (missingKeys.length > 0) throw new SDJWTException(`Missing required claim keys: ${missingKeys.join(", ")}`);
+		}
+		if (!options?.keyBindingNonce) return {
+			payload,
+			header
+		};
+		if (!sdjwt.kbJwt) throw new SDJWTException("Key Binding JWT not exist");
+		if (!this.userConfig.kbVerifier) throw new SDJWTException("Key Binding Verifier not found");
+		const kb = await sdjwt.kbJwt.verifyKB({
+			verifier: this.userConfig.kbVerifier,
+			payload,
+			nonce: options.keyBindingNonce,
+			options
+		});
+		if (!kb) throw new Error("signature is not valid");
+		const sdHashfromKb = kb.payload.sd_hash;
+		const presentSdJwtWithoutKb = new SDJwt({
+			jwt: sdjwt.jwt,
+			disclosures: sdjwt.disclosures
+		}).encodeSDJwt();
+		if (await this.calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher) !== sdHashfromKb) throw new SDJWTException("Invalid sd_hash in Key Binding JWT");
+		return {
+			payload,
+			header,
+			kb
+		};
+	}
+	/**
+	* Safe verification that collects all errors instead of failing fast.
+	* Returns a result object with either the verified data or an array of all errors.
+	*
+	* @param encodedSDJwt - The encoded SD-JWT to verify
+	* @param options - Verification options
+	* @returns A SafeVerifyResult containing either success data or collected errors
+	*/
+	async safeVerify(encodedSDJwt, options) {
+		const errors = [];
+		const addError = (code, message, details) => {
+			errors.push({
+				code,
+				message,
+				details
+			});
+		};
+		const exceptionToCode = (error) => {
+			const message = error.message.toLowerCase();
+			if (message.includes("hasher not found")) return "HASHER_NOT_FOUND";
+			if (message.includes("verifier not found")) return "VERIFIER_NOT_FOUND";
+			if (message.includes("invalid sd jwt") || message.includes("invalid jwt")) return "INVALID_SD_JWT";
+			if (message.includes("not yet valid")) return "JWT_NOT_YET_VALID";
+			if (message.includes("expired")) return "JWT_EXPIRED";
+			if (message.includes("signature")) return "INVALID_JWT_SIGNATURE";
+			if (message.includes("missing required claim")) return "MISSING_REQUIRED_CLAIMS";
+			if (message.includes("key binding jwt not exist")) return "KEY_BINDING_JWT_MISSING";
+			if (message.includes("key binding verifier not found")) return "KEY_BINDING_VERIFIER_NOT_FOUND";
+			if (message.includes("sd_hash")) return "KEY_BINDING_SD_HASH_INVALID";
+			return "UNKNOWN_ERROR";
+		};
+		if (!this.userConfig.hasher) addError("HASHER_NOT_FOUND", "Hasher not found");
+		if (!this.userConfig.verifier) addError("VERIFIER_NOT_FOUND", "Verifier not found");
+		if (errors.length > 0) return {
+			success: false,
+			errors
+		};
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		const hasher = this.userConfig.hasher;
+		let sdjwt;
+		let payload;
+		let header;
+		try {
+			sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
+			if (!sdjwt.jwt?.payload) addError("INVALID_SD_JWT", "Invalid SD JWT: missing JWT or payload");
+		} catch (e) {
+			const error = ensureError(e);
+			addError("INVALID_SD_JWT", `Failed to decode SD-JWT: ${error.message}`, error);
+		}
+		if (sdjwt?.jwt) try {
+			header = (await this.VerifyJwt(sdjwt.jwt, {
+				...options,
+				skipJwtClaimValidation: true
+			})).header;
+			payload = await sdjwt.getClaims(hasher);
+			validateJwtPayload(payload, options);
+		} catch (e) {
+			const error = ensureError(e);
+			addError(exceptionToCode(error), error.message, error);
+		}
+		if (sdjwt && options?.requiredClaimKeys) try {
+			const keys = await sdjwt.keys(hasher);
+			const missingKeys = options.requiredClaimKeys.filter((k) => !keys.includes(k));
+			if (missingKeys.length > 0) addError("MISSING_REQUIRED_CLAIMS", `Missing required claim keys: ${missingKeys.join(", ")}`, { missingKeys });
+		} catch (e) {
+			const error = ensureError(e);
+			addError("UNKNOWN_ERROR", `Failed to check required claims: ${error.message}`, error);
+		}
+		let kb;
+		if (options?.keyBindingNonce && sdjwt) {
+			if (!sdjwt.kbJwt) addError("KEY_BINDING_JWT_MISSING", "Key Binding JWT not exist");
+			else if (!this.userConfig.kbVerifier) addError("KEY_BINDING_VERIFIER_NOT_FOUND", "Key Binding Verifier not found");
+			else if (payload) try {
+				const kbResult = await sdjwt.kbJwt.verifyKB({
+					verifier: this.userConfig.kbVerifier,
+					payload,
+					nonce: options.keyBindingNonce,
+					options
+				});
+				if (!kbResult) addError("KEY_BINDING_SIGNATURE_INVALID", "Key binding signature is not valid");
+				else {
+					kb = kbResult;
+					const presentSdJwtWithoutKb = new SDJwt({
+						jwt: sdjwt.jwt,
+						disclosures: sdjwt.disclosures
+					}).encodeSDJwt();
+					const sdHashStr = await this.calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher);
+					if (sdHashStr !== kbResult.payload.sd_hash) addError("KEY_BINDING_SD_HASH_INVALID", "Invalid sd_hash in Key Binding JWT", {
+						expected: sdHashStr,
+						received: kbResult.payload.sd_hash
+					});
+				}
+			} catch (e) {
+				const error = ensureError(e);
+				addError("KEY_BINDING_SIGNATURE_INVALID", `Key binding verification failed: ${error.message}`, error);
+			}
+		}
+		if (errors.length > 0) return {
+			success: false,
+			errors
+		};
+		return {
+			success: true,
+			data: {
+				payload,
+				header,
+				kb
+			}
+		};
+	}
+	async calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher) {
+		if (!sdjwt.jwt?.payload) throw new SDJWTException("Invalid SD JWT");
+		const { _sd_alg } = getSDAlgAndPayload(sdjwt.jwt.payload);
+		const sdHash = await hasher(presentSdJwtWithoutKb, _sd_alg);
+		return (0, _owf_identity_common.uint8ArrayToBase64Url)(sdHash);
+	}
+	/**
+	* This function is for validating the SD JWT
+	* Checking signature, if provided the iat and exp when provided and return its the claims
+	* @param encodedSDJwt
+	* @param options
+	* @returns
+	*/
+	async validate(encodedSDJwt, options) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		const hasher = this.userConfig.hasher;
+		const sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
+		if (!sdjwt.jwt) throw new SDJWTException("Invalid SD JWT");
+		const verifiedPayloads = await this.VerifyJwt(sdjwt.jwt, {
+			...options,
+			skipJwtClaimValidation: true
+		});
+		const claims = await sdjwt.getClaims(hasher);
+		validateReservedFieldsInternal(claims);
+		validateJwtPayload(claims, options);
+		return {
+			payload: claims,
+			header: verifiedPayloads.header
+		};
+	}
+	config(newConfig) {
+		this.userConfig = {
+			...this.userConfig,
+			...newConfig
+		};
+	}
+	encode(sdJwt) {
+		return sdJwt.encodeSDJwt();
+	}
+	decode(endcodedSDJwt) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		return SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
+	}
+	async keys(endcodedSDJwt) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		return (await SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher)).keys(this.userConfig.hasher);
+	}
+	async presentableKeys(endcodedSDJwt) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		return (await SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher)).presentableKeys(this.userConfig.hasher);
+	}
+	async getClaims(endcodedSDJwt) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		return (await SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher)).getClaims(this.userConfig.hasher);
+	}
+	toFlattenJSON(endcodedSDJwt) {
+		return FlattenJSON.fromEncode(endcodedSDJwt);
+	}
+	toGeneralJSON(endcodedSDJwt) {
+		return GeneralJSON.fromEncode(endcodedSDJwt);
+	}
+};
+var SDJwtGeneralJSONInstance = class {
+	static {
+		this.DEFAULT_hashAlg = "sha-256";
+	}
+	constructor(userConfig) {
+		this.userConfig = {};
+		if (userConfig) {
+			if (userConfig.hashAlg && !IANA_HASH_ALGORITHMS.includes(userConfig.hashAlg)) throw new SDJWTException(`Invalid hash algorithm: ${userConfig.hashAlg}`);
+			const allowedDisclosureHashAlgorithms = userConfig.allowedDisclosureHashAlgorithms ?? DEFAULT_SECURE_HASH_ALGORITHMS;
+			if (userConfig.hashAlg && !allowedDisclosureHashAlgorithms.includes(userConfig.hashAlg)) throw new SDJWTException(`Disallowed hash algorithm: ${userConfig.hashAlg}`);
+			this.userConfig = userConfig;
+		}
+	}
+	async createKBJwt(options, sdHash) {
+		if (!this.userConfig.kbSigner) throw new SDJWTException("Key Binding Signer not found");
+		if (!this.userConfig.kbSignAlg) throw new SDJWTException("Key Binding sign algorithm not specified");
+		const { payload } = options;
+		const kbJwt = new KBJwt({
+			header: {
+				typ: KB_JWT_TYP,
+				alg: this.userConfig.kbSignAlg
+			},
+			payload: {
+				...payload,
+				sd_hash: sdHash
+			}
+		});
+		await kbJwt.sign(this.userConfig.kbSigner);
+		return kbJwt;
+	}
+	encodeObj(obj) {
+		return (0, _owf_identity_common.base64urlEncode)(JSON.stringify(obj));
+	}
+	async issue(payload, disclosureFrame, options) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		if (!this.userConfig.saltGenerator) throw new SDJWTException("SaltGenerator not found");
+		this.validateReservedFields(payload);
+		this.validateDisclosureFrame(disclosureFrame);
+		const hasher = this.userConfig.hasher;
+		const hashAlg = this.userConfig.hashAlg ?? SDJwtInstance.DEFAULT_hashAlg;
+		const { packedClaims, disclosures } = await pack(payload, disclosureFrame, {
+			hasher,
+			alg: hashAlg
+		}, this.userConfig.saltGenerator);
+		const encodedSDJwtPayload = this.encodeObj({
+			...packedClaims,
+			_sd_alg: disclosureFrame ? hashAlg : void 0
+		});
+		return new GeneralJSON({
+			payload: encodedSDJwtPayload,
+			disclosures: disclosures.map((disclosure) => disclosure.encode()),
+			signatures: await Promise.all(options.sigs.map(async (s) => {
+				const { signer, alg, kid, header } = s;
+				const protectedHeader = {
+					typ: this.type,
+					alg,
+					kid,
+					...header
+				};
+				const encodedProtectedHeader = this.encodeObj(protectedHeader);
+				return {
+					protected: encodedProtectedHeader,
+					signature: await signer(`${encodedProtectedHeader}.${encodedSDJwtPayload}`)
+				};
+			}))
+		});
+	}
+	/**
+	* Validates if the payload contains any reserved claim names. If so it will throw an error.
+	* @param payload
+	* @returns
+	*/
+	validateReservedFields(payload) {
+		validateReservedFieldsInternal(payload);
+	}
+	validateDisclosureFrame(_disclosureFrame) {}
+	async present(generalJSON, presentationFrame, options) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		const hasher = this.userConfig.hasher;
+		const encodedSDJwt = generalJSON.toEncoded(0);
+		const sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
+		if (sdjwt.kbJwt) throw new SDJWTException("Holder cannot present an SD-JWT with KB-JWT");
+		if (!sdjwt.jwt?.payload) throw new SDJWTException("Payload not found");
+		const encodedDisclosures = (await sdjwt.getPresentDisclosures(presentationFrame, hasher)).map((d) => d.encode());
+		const presentedGeneralJSON = new GeneralJSON({
+			payload: generalJSON.payload,
+			disclosures: encodedDisclosures,
+			signatures: generalJSON.signatures
+		});
+		if (!options?.kb) return presentedGeneralJSON;
+		const presentSdJwtWithoutKb = await sdjwt.present(presentationFrame, hasher);
+		const sdHashStr = await this.calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher);
+		presentedGeneralJSON.kb_jwt = (await this.createKBJwt(options.kb, sdHashStr)).encodeJwt();
+		return presentedGeneralJSON;
+	}
+	async verify(generalJSON, options) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		const hasher = this.userConfig.hasher;
+		const { payload, headers } = await this.validate(generalJSON, options);
+		const encodedSDJwt = generalJSON.toEncoded(0);
+		const sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
+		if (!sdjwt.jwt?.payload) throw new SDJWTException("Invalid SD JWT");
+		if (options?.requiredClaimKeys) {
+			const keys = await sdjwt.keys(hasher);
+			const missingKeys = options?.requiredClaimKeys.filter((k) => !keys.includes(k));
+			if (missingKeys.length > 0) throw new SDJWTException(`Missing required claim keys: ${missingKeys.join(", ")}`);
+		}
+		if (!options?.keyBindingNonce) return {
+			payload,
+			headers
+		};
+		if (!sdjwt.kbJwt) throw new SDJWTException("Key Binding JWT not exist");
+		if (!this.userConfig.kbVerifier) throw new SDJWTException("Key Binding Verifier not found");
+		const kb = await sdjwt.kbJwt.verifyKB({
+			verifier: this.userConfig.kbVerifier,
+			payload,
+			nonce: options.keyBindingNonce,
+			options
+		});
+		if (!kb) throw new Error("signature is not valid");
+		const sdHashfromKb = kb.payload.sd_hash;
+		const presentSdJwtWithoutKb = new SDJwt({
+			jwt: sdjwt.jwt,
+			disclosures: sdjwt.disclosures
+		}).encodeSDJwt();
+		if (await this.calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher) !== sdHashfromKb) throw new SDJWTException("Invalid sd_hash in Key Binding JWT");
+		return {
+			payload,
+			headers,
+			kb
+		};
+	}
+	async calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher) {
+		if (!sdjwt.jwt?.payload) throw new SDJWTException("Invalid SD JWT");
+		const { _sd_alg } = getSDAlgAndPayload(sdjwt.jwt.payload);
+		const sdHash = await hasher(presentSdJwtWithoutKb, _sd_alg);
+		return (0, _owf_identity_common.uint8ArrayToBase64Url)(sdHash);
+	}
+	async validate(generalJSON, options) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		if (!this.userConfig.verifier) throw new SDJWTException("Verifier not found");
+		const hasher = this.userConfig.hasher;
+		const verifier = this.userConfig.verifier;
+		const { payload, signatures } = generalJSON;
+		const results = await Promise.all(signatures.map(async (s) => {
+			const { protected: encodedHeader, signature } = s;
+			const verified = await verifier(`${encodedHeader}.${payload}`, signature, {
+				...options,
+				skipJwtClaimValidation: true
+			});
+			const header = decodeBase64urlJsonStrict(encodedHeader, "Invalid JWT");
+			if (typeof header.alg !== "string" || header.alg === "none") throw new SDJWTException("Verify Error: alg \"none\" is not allowed");
+			if (options?.allowedIssuerAlgorithms && !options.allowedIssuerAlgorithms.includes(header.alg)) throw new SDJWTException(`Verify Error: Disallowed alg ${header.alg}`);
+			return {
+				verified,
+				header
+			};
+		}));
+		if (!results.every((r) => r.verified)) throw new SDJWTException("Signature is not valid");
+		const encodedSDJwt = generalJSON.toEncoded(0);
+		const sdjwt = await SDJwt.fromEncode(encodedSDJwt, hasher);
+		if (!sdjwt.jwt) throw new SDJWTException("Invalid SD JWT");
+		const claims = await sdjwt.getClaims(hasher);
+		validateReservedFieldsInternal(claims);
+		validateJwtPayload(claims, options);
+		return {
+			payload: claims,
+			headers: results.map((r) => r.header)
+		};
+	}
+	config(newConfig) {
+		this.userConfig = {
+			...this.userConfig,
+			...newConfig
+		};
+	}
+	encode(sdJwt, index) {
+		return sdJwt.toEncoded(index);
+	}
+	decode(endcodedSDJwt) {
+		return GeneralJSON.fromEncode(endcodedSDJwt);
+	}
+	async keys(generalSdjwt) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		const endcodedSDJwt = generalSdjwt.toEncoded(0);
+		return (await SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher)).keys(this.userConfig.hasher);
+	}
+	async presentableKeys(generalSdjwt) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		const endcodedSDJwt = generalSdjwt.toEncoded(0);
+		return (await SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher)).presentableKeys(this.userConfig.hasher);
+	}
+	async getClaims(generalSdjwt) {
+		if (!this.userConfig.hasher) throw new SDJWTException("Hasher not found");
+		const endcodedSDJwt = generalSdjwt.toEncoded(0);
+		return (await SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher)).getClaims(this.userConfig.hasher);
+	}
+};
+//#endregion
+exports.DEFAULT_SECURE_HASH_ALGORITHMS = DEFAULT_SECURE_HASH_ALGORITHMS;
+exports.Disclosure = Disclosure;
+exports.FlattenJSON = FlattenJSON;
+exports.GeneralJSON = GeneralJSON;
+exports.IANA_HASH_ALGORITHMS = IANA_HASH_ALGORITHMS;
+exports.Jwt = Jwt;
+exports.KBJwt = KBJwt;
+exports.KB_JWT_TYP = KB_JWT_TYP;
+exports.SDJWTException = SDJWTException;
+exports.SDJwt = SDJwt;
+exports.SDJwtGeneralJSONInstance = SDJwtGeneralJSONInstance;
+exports.SDJwtInstance = SDJwtInstance;
+exports.SD_DECOY = SD_DECOY;
+exports.SD_DIGEST = SD_DIGEST;
+exports.SD_LIST_KEY = SD_LIST_KEY;
+exports.SD_SEPARATOR = SD_SEPARATOR;
+Object.defineProperty(exports, "base64UrlToUint8Array", {
+	enumerable: true,
+	get: function() {
+		return _owf_identity_common.base64UrlToUint8Array;
+	}
+});
+Object.defineProperty(exports, "base64urlDecode", {
+	enumerable: true,
+	get: function() {
+		return _owf_identity_common.base64urlDecode;
+	}
+});
+Object.defineProperty(exports, "base64urlEncode", {
+	enumerable: true,
+	get: function() {
+		return _owf_identity_common.base64urlEncode;
+	}
+});
+exports.createDecoy = createDecoy;
+exports.createHashMapping = createHashMapping;
+exports.createHashMappingForSerializedDisclosure = createHashMappingForSerializedDisclosure;
+exports.createHashMappingSync = createHashMappingSync;
+exports.decodeJwt = decodeJwt;
+exports.decodeSdJwt = decodeSdJwt;
+exports.decodeSdJwtSync = decodeSdJwtSync;
+exports.encodePath = encodePath;
+exports.encodePathSegment = encodePathSegment;
+exports.ensureError = ensureError;
+exports.getClaims = getClaims;
+exports.getClaimsSync = getClaimsSync;
+exports.getSDAlgAndPayload = getSDAlgAndPayload;
+exports.listKeys = listKeys;
+exports.pack = pack;
+exports.present = present;
+exports.presentSync = presentSync;
+exports.presentableKeys = presentableKeys;
+exports.presentableKeysSync = presentableKeysSync;
+exports.selectDisclosures = selectDisclosures;
+exports.splitSdJwt = splitSdJwt;
+exports.transformPresentationFrame = transformPresentationFrame;
+Object.defineProperty(exports, "uint8ArrayToBase64Url", {
+	enumerable: true,
+	get: function() {
+		return _owf_identity_common.uint8ArrayToBase64Url;
+	}
+});
+exports.unpack = unpack;
+exports.unpackObj = unpackObj;
+exports.unpackSync = unpackSync;
+exports.validateJwtPayload = validateJwtPayload;
+
+//# sourceMappingURL=index.cjs.map