@sd-jwt/core 0.19.1-next.1 → 0.19.1-next.11

package/dist/index.mjs

@@ -17,6 +17,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -38,23 +50,344 @@ var __async = (__this, __arguments, generator) => {
   });
 };
 
-// src/index.ts
-import { getSDAlgAndPayload as getSDAlgAndPayload2 } from "@sd-jwt/decode";
-import {
-  IANA_HASH_ALGORITHMS,
-  KB_JWT_TYP as KB_JWT_TYP2
-} from "@sd-jwt/types";
+// src/types/type.ts
+var SD_SEPARATOR = "~";
+var SD_LIST_KEY = "...";
+var SD_DIGEST = "_sd";
+var SD_DECOY = "_sd_decoy";
+var KB_JWT_TYP = "kb+jwt";
+var 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"
+];
+
+// src/utils/base64url.ts
 import {
+  base64UrlToUint8Array,
   base64urlDecode,
-  base64urlEncode as base64urlEncode3,
-  SDJWTException as SDJWTException6,
-  uint8ArrayToBase64Url as uint8ArrayToBase64Url2
-} from "@sd-jwt/utils";
+  base64urlEncode,
+  uint8ArrayToBase64Url
+} from "@owf/identity-common";
+
+// 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)}` : ""}`;
+  }
+};
+function ensureError(value) {
+  if (value instanceof Error) return value;
+  if (typeof value === "string") return new Error(value);
+  return new Error(String(value));
+}
+
+// src/utils/disclosure.ts
+var Disclosure = class _Disclosure {
+  constructor(data, _meta) {
+    this._digest = _meta == null ? void 0 : _meta.digest;
+    this._encoded = _meta == null ? void 0 : _meta.encoded;
+    if (data.length === 2) {
+      this.salt = data[0];
+      this.value = data[1];
+      return;
+    }
+    if (data.length === 3) {
+      this.salt = data[0];
+      this.key = data[1];
+      this.value = data[2];
+      return;
+    }
+    throw new SDJWTException("Invalid disclosure data");
+  }
+  // We need to digest of the original encoded data.
+  // After decode process, we use JSON.stringify to encode the data.
+  // This can be different from the original encoded data.
+  static fromEncode(s, hash) {
+    return __async(this, null, function* () {
+      const { hasher, alg } = hash;
+      const digest = yield hasher(s, alg);
+      const digestStr = uint8ArrayToBase64Url(digest);
+      const item = JSON.parse(base64urlDecode(s));
+      return _Disclosure.fromArray(item, { digest: digestStr, encoded: s });
+    });
+  }
+  static fromEncodeSync(s, hash) {
+    const { hasher, alg } = hash;
+    const digest = hasher(s, alg);
+    const digestStr = uint8ArrayToBase64Url(digest);
+    const item = JSON.parse(base64urlDecode(s));
+    return _Disclosure.fromArray(item, { digest: digestStr, encoded: s });
+  }
+  static fromArray(item, _meta) {
+    return new _Disclosure(item, _meta);
+  }
+  encode() {
+    if (!this._encoded) {
+      this._encoded = base64urlEncode(JSON.stringify(this.decode()));
+    }
+    return this._encoded;
+  }
+  decode() {
+    return this.key ? [this.salt, this.key, this.value] : [this.salt, this.value];
+  }
+  digest(hash) {
+    return __async(this, null, function* () {
+      const { hasher, alg } = hash;
+      if (!this._digest) {
+        const hash2 = yield hasher(this.encode(), alg);
+        this._digest = uint8ArrayToBase64Url(hash2);
+      }
+      return this._digest;
+    });
+  }
+  digestSync(hash) {
+    const { hasher, alg } = hash;
+    if (!this._digest) {
+      const hash2 = hasher(this.encode(), alg);
+      this._digest = uint8ArrayToBase64Url(hash2);
+    }
+    return this._digest;
+  }
+};
+
+// src/decode/decode.ts
+var decodeJwt = (jwt) => {
+  const { 0: header, 1: payload, 2: signature, length } = jwt.split(".");
+  if (length !== 3) {
+    throw new SDJWTException("Invalid JWT as input");
+  }
+  return {
+    header: JSON.parse(base64urlDecode(header)),
+    payload: JSON.parse(base64urlDecode(payload)),
+    signature
+  };
+};
+var splitSdJwt = (sdjwt) => {
+  const [encodedJwt, ...encodedDisclosures] = sdjwt.split(SD_SEPARATOR);
+  if (encodedDisclosures.length === 0) {
+    return {
+      jwt: encodedJwt,
+      disclosures: []
+    };
+  }
+  const encodedKeyBindingJwt = encodedDisclosures.pop();
+  return {
+    jwt: encodedJwt,
+    disclosures: encodedDisclosures,
+    kbJwt: encodedKeyBindingJwt || void 0
+  };
+};
+var decodeSdJwt = (sdjwt, hasher) => __async(null, null, function* () {
+  const [encodedJwt, ...encodedDisclosures] = sdjwt.split(SD_SEPARATOR);
+  const jwt = decodeJwt(encodedJwt);
+  if (encodedDisclosures.length === 0) {
+    return {
+      jwt,
+      disclosures: []
+    };
+  }
+  const encodedKeyBindingJwt = encodedDisclosures.pop();
+  const kbJwt = encodedKeyBindingJwt ? decodeJwt(encodedKeyBindingJwt) : void 0;
+  const { _sd_alg } = getSDAlgAndPayload(jwt.payload);
+  const disclosures = yield Promise.all(
+    encodedDisclosures.map(
+      (ed) => Disclosure.fromEncode(ed, { alg: _sd_alg, hasher })
+    )
+  );
+  return {
+    jwt,
+    disclosures,
+    kbJwt
+  };
+});
+var decodeSdJwtSync = (sdjwt, hasher) => {
+  const [encodedJwt, ...encodedDisclosures] = sdjwt.split(SD_SEPARATOR);
+  const jwt = decodeJwt(encodedJwt);
+  if (encodedDisclosures.length === 0) {
+    return {
+      jwt,
+      disclosures: []
+    };
+  }
+  const encodedKeyBindingJwt = encodedDisclosures.pop();
+  const kbJwt = encodedKeyBindingJwt ? decodeJwt(encodedKeyBindingJwt) : void 0;
+  const { _sd_alg } = getSDAlgAndPayload(jwt.payload);
+  const disclosures = encodedDisclosures.map(
+    (ed) => Disclosure.fromEncodeSync(ed, { alg: _sd_alg, hasher })
+  );
+  return {
+    jwt,
+    disclosures,
+    kbJwt
+  };
+};
+var getClaims = (rawPayload, disclosures, hasher) => __async(null, null, function* () {
+  const { unpackedObj } = yield unpack(rawPayload, disclosures, hasher);
+  return unpackedObj;
+});
+var getClaimsSync = (rawPayload, disclosures, hasher) => {
+  const { unpackedObj } = unpackSync(rawPayload, disclosures, hasher);
+  return unpackedObj;
+};
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var unpackArray = (arr, map, prefix = "", seenDigests) => {
+  const keys = {};
+  const unpackedArray = [];
+  arr.forEach((item, idx) => {
+    if (isRecord(item)) {
+      const hash = item[SD_LIST_KEY];
+      if (typeof hash === "string") {
+        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) {
+          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 };
+};
+var unpackObj = (obj, map) => {
+  const copiedObj = JSON.parse(JSON.stringify(obj));
+  const seenDigests = /* @__PURE__ */ new Set();
+  const result = unpackObjInternal(copiedObj, map, "", seenDigests);
+  const mapDigests = Object.keys(map);
+  const unusedDigests = mapDigests.filter((d) => !seenDigests.has(d));
+  if (unusedDigests.length > 0) {
+    throw new SDJWTException("Unreferenced disclosure(s) detected in SD-JWT");
+  }
+  return result;
+};
+var 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 (key !== SD_DIGEST && key !== SD_LIST_KEY && typeof record[key] === "object") {
+        const newKey = prefix ? `${prefix}.${key}` : key;
+        const { unpackedObj: unpackedObj2, disclosureKeymap: disclosureKeys } = unpackObjInternal(record[key], map, newKey, seenDigests);
+        record[key] = unpackedObj2;
+        Object.assign(keys, disclosureKeys);
+      }
+    }
+    const _a = record, { _sd } = _a, payload = __objRest(_a, ["_sd"]);
+    const claims = {};
+    if (_sd) {
+      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 == null ? void 0 : disclosed.key) {
+          if (disclosed.key in payload) {
+            throw new SDJWTException(
+              `Disclosed claim name "${disclosed.key}" conflicts with existing payload key`
+            );
+          }
+          const presentKey = prefix ? `${prefix}.${disclosed.key}` : disclosed.key;
+          keys[presentKey] = hash;
+          const { unpackedObj: unpackedObj2, disclosureKeymap: disclosureKeys } = unpackObjInternal(disclosed.value, map, presentKey, seenDigests);
+          claims[disclosed.key] = unpackedObj2;
+          Object.assign(keys, disclosureKeys);
+        }
+      }
+    }
+    const unpackedObj = Object.assign(payload, claims);
+    return { unpackedObj, disclosureKeymap: keys };
+  }
+  return { unpackedObj: obj, disclosureKeymap: keys };
+};
+var createHashMapping = (disclosures, hash) => __async(null, null, function* () {
+  const map = {};
+  for (let i = 0; i < disclosures.length; i++) {
+    const disclosure = disclosures[i];
+    const digest = yield disclosure.digest(hash);
+    map[digest] = disclosure;
+  }
+  return map;
+});
+var createHashMappingSync = (disclosures, hash) => {
+  const map = {};
+  for (let i = 0; i < disclosures.length; i++) {
+    const disclosure = disclosures[i];
+    const digest = disclosure.digestSync(hash);
+    map[digest] = disclosure;
+  }
+  return map;
+};
+var getSDAlgAndPayload = (SdJwtPayload) => {
+  const _a = SdJwtPayload, { _sd_alg } = _a, payload = __objRest(_a, ["_sd_alg"]);
+  if (typeof _sd_alg !== "string") {
+    return { _sd_alg: "sha-256", payload };
+  }
+  return { _sd_alg, payload };
+};
+var unpack = (SdJwtPayload, disclosures, hasher) => __async(null, null, function* () {
+  const { _sd_alg, payload } = getSDAlgAndPayload(SdJwtPayload);
+  const hash = { hasher, alg: _sd_alg };
+  const map = yield createHashMapping(disclosures, hash);
+  return unpackObj(payload, map);
+});
+var unpackSync = (SdJwtPayload, disclosures, hasher) => {
+  const { _sd_alg, payload } = getSDAlgAndPayload(SdJwtPayload);
+  const hash = { hasher, alg: _sd_alg };
+  const map = createHashMappingSync(disclosures, hash);
+  return unpackObj(payload, map);
+};
 
 // src/flattenJSON.ts
-import { splitSdJwt } from "@sd-jwt/decode";
-import { SD_SEPARATOR } from "@sd-jwt/types";
-import { SDJWTException } from "@sd-jwt/utils";
 var FlattenJSON = class _FlattenJSON {
   constructor(data) {
     this.disclosures = data.disclosures;
@@ -117,9 +450,6 @@ var FlattenJSON = class _FlattenJSON {
 };
 
 // src/generalJSON.ts
-import { splitSdJwt as splitSdJwt2 } from "@sd-jwt/decode";
-import { SD_SEPARATOR as SD_SEPARATOR2 } from "@sd-jwt/types";
-import { base64urlEncode, SDJWTException as SDJWTException2 } from "@sd-jwt/utils";
 var GeneralJSON = class _GeneralJSON {
   constructor(data) {
     this.payload = data.payload;
@@ -128,10 +458,10 @@ var GeneralJSON = class _GeneralJSON {
     this.signatures = data.signatures;
   }
   static fromEncode(encodedSdJwt) {
-    const { jwt, disclosures, kbJwt } = splitSdJwt2(encodedSdJwt);
+    const { jwt, disclosures, kbJwt } = splitSdJwt(encodedSdJwt);
     const { 0: protectedHeader, 1: payload, 2: signature } = jwt.split(".");
     if (!protectedHeader || !payload || !signature) {
-      throw new SDJWTException2("Invalid JWT");
+      throw new SDJWTException("Invalid JWT");
     }
     return new _GeneralJSON({
       payload,
@@ -148,7 +478,7 @@ var GeneralJSON = class _GeneralJSON {
   static fromSerialized(json) {
     var _a, _b, _c;
     if (!json.signatures[0]) {
-      throw new SDJWTException2("Invalid JSON");
+      throw new SDJWTException("Invalid JSON");
     }
     const disclosures = (_b = (_a = json.signatures[0].header) == null ? void 0 : _a.disclosures) != null ? _b : [];
     const kb_jwt = (_c = json.signatures[0].header) == null ? void 0 : _c.kb_jwt;
@@ -194,19 +524,19 @@ var GeneralJSON = class _GeneralJSON {
   toEncoded(index) {
     var _a;
     if (index < 0 || index >= this.signatures.length) {
-      throw new SDJWTException2("Index out of bounds");
+      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(SD_SEPARATOR2);
+      const disclosures = this.disclosures.join(SD_SEPARATOR);
       data.push(disclosures);
     }
     const kb = (_a = this.kb_jwt) != null ? _a : "";
     data.push(kb);
-    return data.join(SD_SEPARATOR2);
+    return data.join(SD_SEPARATOR);
   }
   addSignature(protectedHeader, signer, kid) {
     return __async(this, null, function* () {
@@ -222,8 +552,6 @@ var GeneralJSON = class _GeneralJSON {
 };
 
 // src/jwt.ts
-import { decodeJwt } from "@sd-jwt/decode";
-import { base64urlEncode as base64urlEncode2, SDJWTException as SDJWTException3 } from "@sd-jwt/utils";
 var Jwt = class _Jwt {
   constructor(data) {
     this.header = data == null ? void 0 : data.header;
@@ -258,18 +586,18 @@ var Jwt = class _Jwt {
   }
   getUnsignedToken() {
     if (!this.header || !this.payload) {
-      throw new SDJWTException3("Serialize Error: Invalid JWT");
+      throw new SDJWTException("Serialize Error: Invalid JWT");
     }
     if (this.encoded) {
       const parts = this.encoded.split(".");
       if (parts.length !== 3) {
-        throw new SDJWTException3(`Invalid JWT format: ${this.encoded}`);
+        throw new SDJWTException(`Invalid JWT format: ${this.encoded}`);
       }
       const unsignedToken = parts.slice(0, 2).join(".");
       return unsignedToken;
     }
-    const header = base64urlEncode2(JSON.stringify(this.header));
-    const payload = base64urlEncode2(JSON.stringify(this.payload));
+    const header = base64urlEncode(JSON.stringify(this.header));
+    const payload = base64urlEncode(JSON.stringify(this.payload));
     return `${header}.${payload}`;
   }
   sign(signer) {
@@ -284,10 +612,10 @@ var Jwt = class _Jwt {
       return this.encoded;
     }
     if (!this.header || !this.payload || !this.signature) {
-      throw new SDJWTException3("Serialize Error: Invalid JWT");
+      throw new SDJWTException("Serialize Error: Invalid JWT");
     }
-    const header = base64urlEncode2(JSON.stringify(this.header));
-    const payload = base64urlEncode2(JSON.stringify(this.payload));
+    const header = base64urlEncode(JSON.stringify(this.header));
+    const payload = base64urlEncode(JSON.stringify(this.payload));
     const signature = this.signature;
     const compact = `${header}.${payload}.${signature}`;
     this.encoded = compact;
@@ -305,22 +633,25 @@ var Jwt = class _Jwt {
       var _a, _b, _c, _d;
       const skew = (options == null ? void 0 : options.skewSeconds) ? options.skewSeconds : 0;
       const currentDate = (_a = options == null ? void 0 : options.currentDate) != null ? _a : Math.floor(Date.now() / 1e3);
-      if (((_b = this.payload) == null ? void 0 : _b.iat) && this.payload.iat - skew > currentDate) {
-        throw new SDJWTException3("Verify Error: JWT is not yet valid");
+      const iat = (_b = this.payload) == null ? void 0 : _b.iat;
+      const nbf = (_c = this.payload) == null ? void 0 : _c.nbf;
+      const exp = (_d = this.payload) == null ? void 0 : _d.exp;
+      if (typeof iat === "number" && iat - skew > currentDate) {
+        throw new SDJWTException("Verify Error: JWT is not yet valid");
       }
-      if (((_c = this.payload) == null ? void 0 : _c.nbf) && this.payload.nbf - skew > currentDate) {
-        throw new SDJWTException3("Verify Error: JWT is not yet valid");
+      if (typeof nbf === "number" && nbf - skew > currentDate) {
+        throw new SDJWTException("Verify Error: JWT is not yet valid");
       }
-      if (((_d = this.payload) == null ? void 0 : _d.exp) && this.payload.exp + skew < currentDate) {
-        throw new SDJWTException3("Verify Error: JWT is expired");
+      if (typeof exp === "number" && exp + skew < currentDate) {
+        throw new SDJWTException("Verify Error: JWT is expired");
       }
       if (!this.signature) {
-        throw new SDJWTException3("Verify Error: no signature in JWT");
+        throw new SDJWTException("Verify Error: no signature in JWT");
       }
       const data = this.getUnsignedToken();
       const verified = yield verifier(data, this.signature, options);
       if (!verified) {
-        throw new SDJWTException3("Verify Error: Invalid JWT Signature");
+        throw new SDJWTException("Verify Error: Invalid JWT Signature");
       }
       return { payload: this.payload, header: this.header };
     });
@@ -328,35 +659,25 @@ var Jwt = class _Jwt {
 };
 
 // src/kbjwt.ts
-import {
-  KB_JWT_TYP
-} from "@sd-jwt/types";
-import { SDJWTException as SDJWTException4 } from "@sd-jwt/utils";
 var KBJwt = class _KBJwt extends Jwt {
   // Checking the validity of the key binding jwt
   // the type unknown is not good, but we don't know at this point how to get the public key of the signer, this is defined in the kbVerifier
   verifyKB(values) {
     return __async(this, null, function* () {
-      var _a;
       if (!this.header || !this.payload || !this.signature) {
-        throw new SDJWTException4("Verify Error: Invalid JWT");
+        throw new SDJWTException("Verify Error: Invalid JWT");
       }
       if (!this.header.alg || this.header.alg === "none" || !this.header.typ || this.header.typ !== KB_JWT_TYP || !this.payload.iat || !this.payload.aud || !this.payload.nonce || // this is for backward compatibility with version 06
-      !(this.payload.sd_hash || ((_a = this.payload) == null ? void 0 : _a._sd_hash))) {
-        throw new SDJWTException4("Invalid Key Binding Jwt");
-      }
-      const data = this.getUnsignedToken();
-      const verified = yield values.verifier(
-        data,
-        this.signature,
-        values.payload
-      );
-      if (!verified) {
-        throw new SDJWTException4("Verify Error: Invalid JWT Signature");
+      !(this.payload.sd_hash || "_sd_hash" in this.payload && this.payload._sd_hash)) {
+        throw new SDJWTException("Invalid Key Binding Jwt");
       }
       if (this.payload.nonce !== values.nonce) {
-        throw new SDJWTException4("Verify Error: Invalid Nonce");
+        throw new SDJWTException("Verify Error: Invalid Nonce");
       }
+      yield this.verify(
+        (data, sig) => values.verifier(data, sig, values.payload),
+        values.options
+      );
       return { payload: this.payload, header: this.header };
     });
   }
@@ -375,19 +696,7 @@ var KBJwt = class _KBJwt extends Jwt {
   }
 };
 
-// src/sdjwt.ts
-import { createHashMapping, getSDAlgAndPayload, unpack } from "@sd-jwt/decode";
-import { transformPresentationFrame } from "@sd-jwt/present";
-import {
-  SD_DECOY,
-  SD_DIGEST,
-  SD_LIST_KEY,
-  SD_SEPARATOR as SD_SEPARATOR3
-} from "@sd-jwt/types";
-import { Disclosure, SDJWTException as SDJWTException5 } from "@sd-jwt/utils";
-
 // src/decoy.ts
-import { uint8ArrayToBase64Url } from "@sd-jwt/utils";
 var createDecoy = (hash, saltGenerator) => __async(null, null, function* () {
   const { hasher, alg } = hash;
   const salt = yield saltGenerator(16);
@@ -395,6 +704,110 @@ var createDecoy = (hash, saltGenerator) => __async(null, null, function* () {
   return uint8ArrayToBase64Url(decoy);
 });
 
+// src/present/present.ts
+var presentableKeys = (rawPayload, disclosures, hasher) => __async(null, null, function* () {
+  const { disclosureKeymap } = yield unpack(rawPayload, disclosures, hasher);
+  return Object.keys(disclosureKeymap).sort();
+});
+var presentableKeysSync = (rawPayload, disclosures, hasher) => {
+  const { disclosureKeymap } = unpackSync(rawPayload, disclosures, hasher);
+  return Object.keys(disclosureKeymap).sort();
+};
+var present = (sdJwt, presentFrame, hasher) => __async(null, null, function* () {
+  const { jwt, kbJwt } = splitSdJwt(sdJwt);
+  const {
+    jwt: { payload },
+    disclosures
+  } = yield decodeSdJwt(sdJwt, hasher);
+  const { _sd_alg: alg } = getSDAlgAndPayload(payload);
+  const hash = { alg, hasher };
+  const keys = transformPresentationFrame(presentFrame);
+  const hashmap = yield createHashMapping(disclosures, hash);
+  const { disclosureKeymap } = yield unpack(payload, disclosures, hasher);
+  const presentedDisclosures = keys.map((k) => hashmap[disclosureKeymap[k]]).filter((d) => d !== void 0);
+  return [
+    jwt,
+    ...presentedDisclosures.map((d) => d.encode()),
+    kbJwt != null ? kbJwt : ""
+  ].join(SD_SEPARATOR);
+});
+var 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);
+  const presentedDisclosures = keys.map((k) => hashmap[disclosureKeymap[k]]).filter((d) => d !== void 0);
+  return [
+    jwt,
+    ...presentedDisclosures.map((d) => d.encode()),
+    kbJwt != null ? kbJwt : ""
+  ].join(SD_SEPARATOR);
+};
+var transformPresentationFrame = (obj, prefix = "") => {
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    const newPrefix = prefix ? `${prefix}.${key}` : key;
+    if (typeof value === "boolean") {
+      if (value) {
+        acc.push(newPrefix);
+      }
+    } else if (typeof value === "object" && value !== null) {
+      acc.push(
+        newPrefix,
+        ...transformPresentationFrame(
+          value,
+          newPrefix
+        )
+      );
+    }
+    return acc;
+  }, []);
+};
+var createHashMappingForSerializedDisclosure = (disclosures) => {
+  const map = {};
+  for (let i = 0; i < disclosures.length; i++) {
+    const disclosure = disclosures[i];
+    const { digest, encoded, key, salt, value } = disclosure;
+    map[digest] = Disclosure.fromArray(
+      key ? [salt, key, value] : [salt, value],
+      { digest, encoded }
+    );
+  }
+  return map;
+};
+var selectDisclosures = (payload, disclosures, presentationFrame) => {
+  if (disclosures.length === 0) {
+    return [];
+  }
+  const hashmap = createHashMappingForSerializedDisclosure(disclosures);
+  const { disclosureKeymap } = unpackObj(payload, hashmap);
+  const keys = transformPresentationFrame(presentationFrame);
+  const presentedDisclosures = keys.map((k) => hashmap[disclosureKeymap[k]]).filter((d) => d !== void 0);
+  const selectedDisclosures = presentedDisclosures.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
+      };
+    }
+  );
+  return selectedDisclosures;
+};
+
 // src/sdjwt.ts
 var SDJwt = class _SDJwt {
   constructor(data) {
@@ -404,7 +817,7 @@ var SDJwt = class _SDJwt {
   }
   static decodeSDJwt(sdjwt, hasher) {
     return __async(this, null, function* () {
-      const [encodedJwt, ...encodedDisclosures] = sdjwt.split(SD_SEPARATOR3);
+      const [encodedJwt, ...encodedDisclosures] = sdjwt.split(SD_SEPARATOR);
       const jwt = Jwt.fromEncode(encodedJwt);
       if (!jwt.payload) {
         throw new Error("Payload is undefined on the JWT. Invalid state reached");
@@ -432,7 +845,7 @@ var SDJwt = class _SDJwt {
   }
   static extractJwt(encodedSdJwt) {
     return __async(this, null, function* () {
-      const [encodedJwt, ..._encodedDisclosures] = encodedSdJwt.split(SD_SEPARATOR3);
+      const [encodedJwt, ..._encodedDisclosures] = encodedSdJwt.split(SD_SEPARATOR);
       return Jwt.fromEncode(encodedJwt);
     });
   }
@@ -461,7 +874,7 @@ var SDJwt = class _SDJwt {
     return __async(this, null, function* () {
       var _a;
       if (!((_a = this.jwt) == null ? void 0 : _a.payload) || !this.disclosures) {
-        throw new SDJWTException5("Invalid sd-jwt: jwt or disclosures is missing");
+        throw new SDJWTException("Invalid sd-jwt: jwt or disclosures is missing");
       }
       const { _sd_alg: alg } = getSDAlgAndPayload(this.jwt.payload);
       const hash = { alg, hasher };
@@ -479,16 +892,16 @@ var SDJwt = class _SDJwt {
   encodeSDJwt() {
     const data = [];
     if (!this.jwt) {
-      throw new SDJWTException5("Invalid sd-jwt: jwt is missing");
+      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(SD_SEPARATOR3);
+      const encodeddisclosures = this.disclosures.map((dc) => dc.encode()).join(SD_SEPARATOR);
       data.push(encodeddisclosures);
     }
     data.push(this.kbJwt ? this.kbJwt.encodeJwt() : "");
-    return data.join(SD_SEPARATOR3);
+    return data.join(SD_SEPARATOR);
   }
   keys(hasher) {
     return __async(this, null, function* () {
@@ -499,7 +912,7 @@ var SDJwt = class _SDJwt {
     return __async(this, null, function* () {
       var _a, _b;
       if (!((_a = this.jwt) == null ? void 0 : _a.payload) || !this.disclosures) {
-        throw new SDJWTException5("Invalid sd-jwt: jwt or disclosures is missing");
+        throw new SDJWTException("Invalid sd-jwt: jwt or disclosures is missing");
       }
       const { disclosureKeymap } = yield unpack(
         (_b = this.jwt) == null ? void 0 : _b.payload,
@@ -513,7 +926,7 @@ var SDJwt = class _SDJwt {
     return __async(this, null, function* () {
       var _a;
       if (!((_a = this.jwt) == null ? void 0 : _a.payload) || !this.disclosures) {
-        throw new SDJWTException5("Invalid sd-jwt: jwt or disclosures is missing");
+        throw new SDJWTException("Invalid sd-jwt: jwt or disclosures is missing");
       }
       const { unpackedObj } = yield unpack(
         this.jwt.payload,
@@ -530,8 +943,9 @@ var listKeys = (obj, prefix = "") => {
     if (obj[key] === void 0) continue;
     const newKey = prefix ? `${prefix}.${key}` : key;
     keys.push(newKey);
-    if (obj[key] && typeof obj[key] === "object" && obj[key] !== null) {
-      keys.push(...listKeys(obj[key], newKey));
+    const value = obj[key];
+    if (value && typeof value === "object") {
+      keys.push(...listKeys(value, newKey));
     }
   }
   return keys;
@@ -626,7 +1040,7 @@ var _SDJwtInstance = class _SDJwtInstance {
     this.userConfig = {};
     if (userConfig) {
       if (userConfig.hashAlg && !IANA_HASH_ALGORITHMS.includes(userConfig.hashAlg)) {
-        throw new SDJWTException6(
+        throw new SDJWTException(
           `Invalid hash algorithm: ${userConfig.hashAlg}`
         );
       }
@@ -636,15 +1050,15 @@ var _SDJwtInstance = class _SDJwtInstance {
   createKBJwt(options, sdHash) {
     return __async(this, null, function* () {
       if (!this.userConfig.kbSigner) {
-        throw new SDJWTException6("Key Binding Signer not found");
+        throw new SDJWTException("Key Binding Signer not found");
       }
       if (!this.userConfig.kbSignAlg) {
-        throw new SDJWTException6("Key Binding sign algorithm not specified");
+        throw new SDJWTException("Key Binding sign algorithm not specified");
       }
       const { payload } = options;
       const kbJwt = new KBJwt({
         header: {
-          typ: KB_JWT_TYP2,
+          typ: KB_JWT_TYP,
           alg: this.userConfig.kbSignAlg
         },
         payload: __spreadProps(__spreadValues({}, payload), { sd_hash: sdHash })
@@ -656,7 +1070,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   SignJwt(jwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.signer) {
-        throw new SDJWTException6("Signer not found");
+        throw new SDJWTException("Signer not found");
       }
       yield jwt.sign(this.userConfig.signer);
       return jwt;
@@ -665,7 +1079,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   VerifyJwt(jwt, options) {
     return __async(this, null, function* () {
       if (!this.userConfig.verifier) {
-        throw new SDJWTException6("Verifier not found");
+        throw new SDJWTException("Verifier not found");
       }
       return jwt.verify(this.userConfig.verifier, options);
     });
@@ -674,13 +1088,13 @@ var _SDJwtInstance = class _SDJwtInstance {
     return __async(this, null, function* () {
       var _a, _b;
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       if (!this.userConfig.saltGenerator) {
-        throw new SDJWTException6("SaltGenerator not found");
+        throw new SDJWTException("SaltGenerator not found");
       }
       if (!this.userConfig.signAlg) {
-        throw new SDJWTException6("sign alogrithm not specified");
+        throw new SDJWTException("sign alogrithm not specified");
       }
       if (disclosureFrame) {
         this.validateReservedFields(disclosureFrame);
@@ -723,11 +1137,11 @@ var _SDJwtInstance = class _SDJwtInstance {
     return __async(this, null, function* () {
       var _a;
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const hasher = this.userConfig.hasher;
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
-      if (!((_a = sdjwt.jwt) == null ? void 0 : _a.payload)) throw new SDJWTException6("Payload not found");
+      if (!((_a = sdjwt.jwt) == null ? void 0 : _a.payload)) throw new SDJWTException("Payload not found");
       const presentSdJwtWithoutKb = yield sdjwt.present(
         presentationFrame,
         hasher
@@ -750,12 +1164,12 @@ var _SDJwtInstance = class _SDJwtInstance {
   verify(encodedSDJwt, options) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const hasher = this.userConfig.hasher;
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
       if (!sdjwt.jwt || !sdjwt.jwt.payload) {
-        throw new SDJWTException6("Invalid SD JWT");
+        throw new SDJWTException("Invalid SD JWT");
       }
       const { payload, header } = yield this.validate(encodedSDJwt, options);
       if (options == null ? void 0 : options.requiredClaimKeys) {
@@ -764,7 +1178,7 @@ var _SDJwtInstance = class _SDJwtInstance {
           (k) => !keys.includes(k)
         );
         if (missingKeys.length > 0) {
-          throw new SDJWTException6(
+          throw new SDJWTException(
             `Missing required claim keys: ${missingKeys.join(", ")}`
           );
         }
@@ -773,15 +1187,16 @@ var _SDJwtInstance = class _SDJwtInstance {
         return { payload, header };
       }
       if (!sdjwt.kbJwt) {
-        throw new SDJWTException6("Key Binding JWT not exist");
+        throw new SDJWTException("Key Binding JWT not exist");
       }
       if (!this.userConfig.kbVerifier) {
-        throw new SDJWTException6("Key Binding Verifier not found");
+        throw new SDJWTException("Key Binding Verifier not found");
       }
       const kb = yield sdjwt.kbJwt.verifyKB({
         verifier: this.userConfig.kbVerifier,
         payload,
-        nonce: options.keyBindingNonce
+        nonce: options.keyBindingNonce,
+        options
       });
       if (!kb) {
         throw new Error("signature is not valid");
@@ -798,19 +1213,182 @@ var _SDJwtInstance = class _SDJwtInstance {
         hasher
       );
       if (sdHashStr !== sdHashfromKb) {
-        throw new SDJWTException6("Invalid sd_hash in Key Binding JWT");
+        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
+   */
+  safeVerify(encodedSDJwt, options) {
+    return __async(this, null, function* () {
+      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 = yield SDJwt.fromEncode(encodedSDJwt, hasher);
+        if (!sdjwt.jwt || !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 == null ? void 0 : sdjwt.jwt) {
+        try {
+          const result = yield this.VerifyJwt(sdjwt.jwt, options);
+          header = result.header;
+          const claims = yield sdjwt.getClaims(hasher);
+          payload = claims;
+        } catch (e) {
+          const error = ensureError(e);
+          const code = exceptionToCode(error);
+          addError(code, error.message, error);
+        }
+      }
+      if (sdjwt && (options == null ? void 0 : options.requiredClaimKeys)) {
+        try {
+          const keys = yield 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 == null ? void 0 : 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 = yield 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 sdjwtWithoutKb = new SDJwt({
+                jwt: sdjwt.jwt,
+                disclosures: sdjwt.disclosures
+              });
+              const presentSdJwtWithoutKb = sdjwtWithoutKb.encodeSDJwt();
+              const sdHashStr = yield 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
+        }
+      };
+    });
+  }
   calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher) {
     return __async(this, null, function* () {
       if (!sdjwt.jwt || !sdjwt.jwt.payload) {
-        throw new SDJWTException6("Invalid SD JWT");
+        throw new SDJWTException("Invalid SD JWT");
       }
-      const { _sd_alg } = getSDAlgAndPayload2(sdjwt.jwt.payload);
+      const { _sd_alg } = getSDAlgAndPayload(sdjwt.jwt.payload);
       const sdHash = yield hasher(presentSdJwtWithoutKb, _sd_alg);
-      const sdHashStr = uint8ArrayToBase64Url2(sdHash);
+      const sdHashStr = uint8ArrayToBase64Url(sdHash);
       return sdHashStr;
     });
   }
@@ -824,12 +1402,12 @@ var _SDJwtInstance = class _SDJwtInstance {
   validate(encodedSDJwt, options) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const hasher = this.userConfig.hasher;
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
       if (!sdjwt.jwt) {
-        throw new SDJWTException6("Invalid SD JWT");
+        throw new SDJWTException("Invalid SD JWT");
       }
       const verifiedPayloads = yield this.VerifyJwt(sdjwt.jwt, options);
       const claims = yield sdjwt.getClaims(hasher);
@@ -844,14 +1422,14 @@ var _SDJwtInstance = class _SDJwtInstance {
   }
   decode(endcodedSDJwt) {
     if (!this.userConfig.hasher) {
-      throw new SDJWTException6("Hasher not found");
+      throw new SDJWTException("Hasher not found");
     }
     return SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
   }
   keys(endcodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
       return sdjwt.keys(this.userConfig.hasher);
@@ -860,7 +1438,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   presentableKeys(endcodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
       return sdjwt.presentableKeys(this.userConfig.hasher);
@@ -869,7 +1447,7 @@ var _SDJwtInstance = class _SDJwtInstance {
   getClaims(endcodedSDJwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
       return sdjwt.getClaims(this.userConfig.hasher);
@@ -889,7 +1467,7 @@ var SDJwtGeneralJSONInstance = class {
     this.userConfig = {};
     if (userConfig) {
       if (userConfig.hashAlg && !IANA_HASH_ALGORITHMS.includes(userConfig.hashAlg)) {
-        throw new SDJWTException6(
+        throw new SDJWTException(
           `Invalid hash algorithm: ${userConfig.hashAlg}`
         );
       }
@@ -899,15 +1477,15 @@ var SDJwtGeneralJSONInstance = class {
   createKBJwt(options, sdHash) {
     return __async(this, null, function* () {
       if (!this.userConfig.kbSigner) {
-        throw new SDJWTException6("Key Binding Signer not found");
+        throw new SDJWTException("Key Binding Signer not found");
       }
       if (!this.userConfig.kbSignAlg) {
-        throw new SDJWTException6("Key Binding sign algorithm not specified");
+        throw new SDJWTException("Key Binding sign algorithm not specified");
       }
       const { payload } = options;
       const kbJwt = new KBJwt({
         header: {
-          typ: KB_JWT_TYP2,
+          typ: KB_JWT_TYP,
           alg: this.userConfig.kbSignAlg
         },
         payload: __spreadProps(__spreadValues({}, payload), { sd_hash: sdHash })
@@ -917,16 +1495,16 @@ var SDJwtGeneralJSONInstance = class {
     });
   }
   encodeObj(obj) {
-    return base64urlEncode3(JSON.stringify(obj));
+    return base64urlEncode(JSON.stringify(obj));
   }
   issue(payload, disclosureFrame, options) {
     return __async(this, null, function* () {
       var _a;
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       if (!this.userConfig.saltGenerator) {
-        throw new SDJWTException6("SaltGenerator not found");
+        throw new SDJWTException("SaltGenerator not found");
       }
       if (disclosureFrame) {
         this.validateReservedFields(disclosureFrame);
@@ -978,12 +1556,12 @@ var SDJwtGeneralJSONInstance = class {
     return __async(this, null, function* () {
       var _a;
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const hasher = this.userConfig.hasher;
       const encodedSDJwt = generalJSON.toEncoded(0);
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
-      if (!((_a = sdjwt.jwt) == null ? void 0 : _a.payload)) throw new SDJWTException6("Payload not found");
+      if (!((_a = sdjwt.jwt) == null ? void 0 : _a.payload)) throw new SDJWTException("Payload not found");
       const disclosures = yield sdjwt.getPresentDisclosures(
         presentationFrame,
         hasher
@@ -1018,14 +1596,14 @@ var SDJwtGeneralJSONInstance = class {
   verify(generalJSON, options) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const hasher = this.userConfig.hasher;
       const { payload, headers } = yield this.validate(generalJSON);
       const encodedSDJwt = generalJSON.toEncoded(0);
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
       if (!sdjwt.jwt || !sdjwt.jwt.payload) {
-        throw new SDJWTException6("Invalid SD JWT");
+        throw new SDJWTException("Invalid SD JWT");
       }
       if (options == null ? void 0 : options.requiredClaimKeys) {
         const keys = yield sdjwt.keys(hasher);
@@ -1033,7 +1611,7 @@ var SDJwtGeneralJSONInstance = class {
           (k) => !keys.includes(k)
         );
         if (missingKeys.length > 0) {
-          throw new SDJWTException6(
+          throw new SDJWTException(
             `Missing required claim keys: ${missingKeys.join(", ")}`
           );
         }
@@ -1042,15 +1620,16 @@ var SDJwtGeneralJSONInstance = class {
         return { payload, headers };
       }
       if (!sdjwt.kbJwt) {
-        throw new SDJWTException6("Key Binding JWT not exist");
+        throw new SDJWTException("Key Binding JWT not exist");
       }
       if (!this.userConfig.kbVerifier) {
-        throw new SDJWTException6("Key Binding Verifier not found");
+        throw new SDJWTException("Key Binding Verifier not found");
       }
       const kb = yield sdjwt.kbJwt.verifyKB({
         verifier: this.userConfig.kbVerifier,
         payload,
-        nonce: options.keyBindingNonce
+        nonce: options.keyBindingNonce,
+        options
       });
       if (!kb) {
         throw new Error("signature is not valid");
@@ -1067,7 +1646,7 @@ var SDJwtGeneralJSONInstance = class {
         hasher
       );
       if (sdHashStr !== sdHashfromKb) {
-        throw new SDJWTException6("Invalid sd_hash in Key Binding JWT");
+        throw new SDJWTException("Invalid sd_hash in Key Binding JWT");
       }
       return { payload, headers, kb };
     });
@@ -1075,11 +1654,11 @@ var SDJwtGeneralJSONInstance = class {
   calculateSDHash(presentSdJwtWithoutKb, sdjwt, hasher) {
     return __async(this, null, function* () {
       if (!sdjwt.jwt || !sdjwt.jwt.payload) {
-        throw new SDJWTException6("Invalid SD JWT");
+        throw new SDJWTException("Invalid SD JWT");
       }
-      const { _sd_alg } = getSDAlgAndPayload2(sdjwt.jwt.payload);
+      const { _sd_alg } = getSDAlgAndPayload(sdjwt.jwt.payload);
       const sdHash = yield hasher(presentSdJwtWithoutKb, _sd_alg);
-      const sdHashStr = uint8ArrayToBase64Url2(sdHash);
+      const sdHashStr = uint8ArrayToBase64Url(sdHash);
       return sdHashStr;
     });
   }
@@ -1088,10 +1667,10 @@ var SDJwtGeneralJSONInstance = class {
   validate(generalJSON) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       if (!this.userConfig.verifier) {
-        throw new SDJWTException6("Verifier not found");
+        throw new SDJWTException("Verifier not found");
       }
       const hasher = this.userConfig.hasher;
       const verifier = this.userConfig.verifier;
@@ -1109,12 +1688,12 @@ var SDJwtGeneralJSONInstance = class {
       );
       const verified = results.every((r) => r.verified);
       if (!verified) {
-        throw new SDJWTException6("Signature is not valid");
+        throw new SDJWTException("Signature is not valid");
       }
       const encodedSDJwt = generalJSON.toEncoded(0);
       const sdjwt = yield SDJwt.fromEncode(encodedSDJwt, hasher);
       if (!sdjwt.jwt) {
-        throw new SDJWTException6("Invalid SD JWT");
+        throw new SDJWTException("Invalid SD JWT");
       }
       const claims = yield sdjwt.getClaims(hasher);
       return { payload: claims, headers: results.map((r) => r.header) };
@@ -1132,7 +1711,7 @@ var SDJwtGeneralJSONInstance = class {
   keys(generalSdjwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const endcodedSDJwt = generalSdjwt.toEncoded(0);
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
@@ -1142,7 +1721,7 @@ var SDJwtGeneralJSONInstance = class {
   presentableKeys(generalSdjwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const endcodedSDJwt = generalSdjwt.toEncoded(0);
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
@@ -1152,7 +1731,7 @@ var SDJwtGeneralJSONInstance = class {
   getClaims(generalSdjwt) {
     return __async(this, null, function* () {
       if (!this.userConfig.hasher) {
-        throw new SDJWTException6("Hasher not found");
+        throw new SDJWTException("Hasher not found");
       }
       const endcodedSDJwt = generalSdjwt.toEncoded(0);
       const sdjwt = yield SDJwt.fromEncode(endcodedSDJwt, this.userConfig.hasher);
@@ -1162,14 +1741,46 @@ var SDJwtGeneralJSONInstance = class {
 };
 SDJwtGeneralJSONInstance.DEFAULT_hashAlg = "sha-256";
 export {
+  Disclosure,
   FlattenJSON,
   GeneralJSON,
+  IANA_HASH_ALGORITHMS,
   Jwt,
   KBJwt,
+  KB_JWT_TYP,
+  SDJWTException,
   SDJwt,
   SDJwtGeneralJSONInstance,
   SDJwtInstance,
+  SD_DECOY,
+  SD_DIGEST,
+  SD_LIST_KEY,
+  SD_SEPARATOR,
+  base64UrlToUint8Array,
+  base64urlDecode,
+  base64urlEncode,
   createDecoy,
+  createHashMapping,
+  createHashMappingForSerializedDisclosure,
+  createHashMappingSync,
+  decodeJwt,
+  decodeSdJwt,
+  decodeSdJwtSync,
+  ensureError,
+  getClaims,
+  getClaimsSync,
+  getSDAlgAndPayload,
   listKeys,
-  pack
+  pack,
+  present,
+  presentSync,
+  presentableKeys,
+  presentableKeysSync,
+  selectDisclosures,
+  splitSdJwt,
+  transformPresentationFrame,
+  uint8ArrayToBase64Url,
+  unpack,
+  unpackObj,
+  unpackSync
 };