@credo-ts/core 0.6.1-pr-2091-20241119140918 → 0.6.1

package/build/utils/array.mjs

@@ -0,0 +1,16 @@
+
+
+//#region src/utils/array.ts
+const asArray = (val) => {
+	if (!val) return [];
+	if (Array.isArray(val)) return val;
+	return [val];
+};
+const mapSingleOrArray = (value, fn) => {
+	const mapped = asArray(value).map(fn);
+	return Array.isArray(value) ? mapped : mapped[0];
+};
+
+//#endregion
+export { asArray, mapSingleOrArray };
+//# sourceMappingURL=array.mjs.map

package/build/utils/array.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.mjs","names":[],"sources":["../../src/utils/array.ts"],"sourcesContent":["import type { SingleOrArray } from '../types'\n\nexport const asArray = <T>(val?: SingleOrArray<T>): Array<T> => {\n  if (!val) return []\n  if (Array.isArray(val)) return val\n  return [val]\n}\n\ntype ExtractValueFromSingleOrArray<V> = V extends SingleOrArray<infer Value> ? Value : never\n\nexport const mapSingleOrArray = <Wrapper extends SingleOrArray<unknown>, Return>(\n  value: Wrapper,\n  fn: (value: ExtractValueFromSingleOrArray<Wrapper>) => Return\n): SingleOrArray<Return> => {\n  const mapped = asArray<ExtractValueFromSingleOrArray<Wrapper>>(value as []).map(fn)\n\n  // We need to return a single or array value based on the input type\n  return Array.isArray(value) ? mapped : mapped[0]\n}\n"],"mappings":";;;AAEA,MAAa,WAAc,QAAqC;AAC9D,KAAI,CAAC,IAAK,QAAO,EAAE;AACnB,KAAI,MAAM,QAAQ,IAAI,CAAE,QAAO;AAC/B,QAAO,CAAC,IAAI;;AAKd,MAAa,oBACX,OACA,OAC0B;CAC1B,MAAM,SAAS,QAAgD,MAAY,CAAC,IAAI,GAAG;AAGnF,QAAO,MAAM,QAAQ,MAAM,GAAG,SAAS,OAAO"}

package/build/utils/base58.mjs

@@ -0,0 +1,16 @@
+
+
+import base from "@multiformats/base-x";
+
+//#region src/utils/base58.ts
+const base58Converter = base("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+function decodeFromBase58(base58) {
+	return base58Converter.decode(base58);
+}
+function encodeToBase58(buffer) {
+	return base58Converter.encode(buffer);
+}
+
+//#endregion
+export { decodeFromBase58, encodeToBase58 };
+//# sourceMappingURL=base58.mjs.map

package/build/utils/base58.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base58.mjs","names":[],"sources":["../../src/utils/base58.ts"],"sourcesContent":["import base from '@multiformats/base-x'\nimport type { AnyUint8Array, Uint8ArrayBuffer } from '../types'\n\nconst BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nconst base58Converter = base(BASE58_ALPHABET)\n\nexport function decodeFromBase58(base58: string): Uint8ArrayBuffer {\n  return base58Converter.decode(base58) as Uint8ArrayBuffer\n}\n\nexport function encodeToBase58(buffer: AnyUint8Array) {\n  return base58Converter.encode(buffer)\n}\n"],"mappings":";;;;;AAKA,MAAM,kBAAkB,KAFA,6DAEqB;AAE7C,SAAgB,iBAAiB,QAAkC;AACjE,QAAO,gBAAgB,OAAO,OAAO;;AAGvC,SAAgB,eAAe,QAAuB;AACpD,QAAO,gBAAgB,OAAO,OAAO"}

package/build/utils/base64.d.mts

@@ -0,0 +1,5 @@
+//#region src/utils/base64.d.ts
+declare function base64ToBase64URL(base64: string): string;
+//#endregion
+export { base64ToBase64URL };
+//# sourceMappingURL=base64.d.mts.map

package/build/utils/base64.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.mts","names":[],"sources":["../../src/utils/base64.ts"],"sourcesContent":[],"mappings":";iBAAgB,iBAAA"}

package/build/utils/base64.mjs

@@ -0,0 +1,10 @@
+
+
+//#region src/utils/base64.ts
+function base64ToBase64URL(base64) {
+	return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+//#endregion
+export { base64ToBase64URL };
+//# sourceMappingURL=base64.mjs.map

package/build/utils/base64.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.mjs","names":[],"sources":["../../src/utils/base64.ts"],"sourcesContent":["export function base64ToBase64URL(base64: string) {\n  return base64.replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=/g, '')\n}\n"],"mappings":";;;AAAA,SAAgB,kBAAkB,QAAgB;AAChD,QAAO,OAAO,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,MAAM,GAAG"}

package/build/utils/buffer.d.mts

@@ -0,0 +1,2 @@
+import { Buffer } from "buffer";
+export { Buffer };

package/build/utils/buffer.mjs

@@ -0,0 +1,5 @@
+
+
+import { Buffer } from "buffer";
+
+export { Buffer };

package/build/utils/credentialUse.d.mts

@@ -0,0 +1,84 @@
+import { CredentialMultiInstanceState, CredentialMultiInstanceUseMode, CredentialMultiInstanceUseUpdateMode } from "./credentialUseTypes.mjs";
+import { SdJwtVc } from "../modules/sd-jwt-vc/SdJwtVcService.mjs";
+import { SdJwtVcRecord } from "../modules/sd-jwt-vc/repository/SdJwtVcRecord.mjs";
+import "../modules/sd-jwt-vc/repository/index.mjs";
+import { MdocRecord } from "../modules/mdoc/repository/MdocRecord.mjs";
+import "../modules/mdoc/repository/index.mjs";
+import { W3cCredentialRecord } from "../modules/vc/repository/W3cCredentialRecord.mjs";
+import { W3cV2CredentialRecord } from "../modules/vc/repository/W3cV2CredentialRecord.mjs";
+import "../modules/vc/repository/index.mjs";
+import { W3cV2VerifiableCredential } from "../modules/vc/models/credential/W3cV2VerifiableCredential.mjs";
+import { W3cVerifiableCredential } from "../modules/vc/models/credential/W3cVerifiableCredential.mjs";
+import "../modules/vc/index.mjs";
+import { Mdoc } from "../modules/mdoc/Mdoc.mjs";
+import { AgentContext } from "../agent/context/AgentContext.mjs";
+import "../agent/index.mjs";
+
+//#region src/utils/credentialUse.d.ts
+type CredentialRecord = W3cCredentialRecord | SdJwtVcRecord | MdocRecord | W3cV2CredentialRecord;
+type CredentialInstanceReturnType<Record extends CredentialRecord> = Record extends W3cCredentialRecord ? W3cVerifiableCredential : Record extends W3cV2CredentialRecord ? W3cV2VerifiableCredential : Record extends SdJwtVcRecord ? SdJwtVc : Record extends MdocRecord ? Mdoc : CredentialRecord;
+/**
+ * Checks whether an instance can be used from the provided record based on
+ * the required credential use mode.
+ */
+declare function canUseInstanceFromCredentialRecord({
+  credentialRecord,
+  useMode
+}: {
+  credentialRecord: CredentialRecord;
+  useMode: CredentialMultiInstanceUseMode;
+}): boolean;
+interface UseInstanceFromCredentialRecordOptions<Record extends CredentialRecord> {
+  agentContext: AgentContext;
+  /**
+   * Which mode to use for usage of the credential instance. See {@link CredentialMultiInstanceUseMode} for
+   * more information on the available options
+   */
+  useMode: CredentialMultiInstanceUseMode;
+  credentialRecord: Record;
+  /**
+   * The update mode for the credential record when a new instance is used.
+   *
+   * @default `CredentialMultiInstanceUseUpdateMode.RefetchAndUpdateWithLock`
+   */
+  updateMode?: CredentialMultiInstanceUseUpdateMode;
+}
+interface UseInstanceFromCredentialRecordReturn<Record extends CredentialRecord> {
+  /**
+   * The credential instance with the kms key id
+   */
+  credentialInstance: CredentialInstanceReturnType<Record>;
+  /**
+   * If the first instance was used, this value will be `true`. The first time
+   * the first instance is used, technically the credential is not reused yet,
+   * but we make no distinction between this.
+   */
+  isReused: boolean;
+  /**
+   * Whether the last new instance was used. If `isReused` is `true` this value will
+   * always be `false`.
+   *
+   * The last new instance is the second entry in the mdoc instances, since the first
+   * one is reserved for 'reused' usage.
+   */
+  isLastNewInstance: boolean;
+}
+/**
+ * Extract an instance with the correct kms key id from the credential instances
+ * on the record. Note that if an instance is extracted (that is not reused) it
+ * will remove the instance from the record, and the record should be updated in
+ * storage after usage.
+ *
+ * Note that the last credential instance is never removed from the record. So if the
+ * method indicates the last instance has been used, you should remove the credential
+ * from storage if you don't want it to be used anymore in the future.
+ */
+declare function useInstanceFromCredentialRecord<Record extends CredentialRecord>({
+  credentialRecord,
+  useMode,
+  agentContext,
+  updateMode
+}: UseInstanceFromCredentialRecordOptions<Record>): Promise<UseInstanceFromCredentialRecordReturn<Record>>;
+//#endregion
+export { UseInstanceFromCredentialRecordOptions, UseInstanceFromCredentialRecordReturn, canUseInstanceFromCredentialRecord, useInstanceFromCredentialRecord };
+//# sourceMappingURL=credentialUse.d.mts.map

package/build/utils/credentialUse.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentialUse.d.mts","names":[],"sources":["../../src/utils/credentialUse.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;KA+BK,gBAAA,GAAmB,sBAAsB,gBAAgB,aAAa;KAEtE,4CAA4C,oBAAoB,eAAe,sBAChF,0BACA,eAAe,wBACb,4BACA,eAAe,gBACb,UACA,eAAe,aACb,OACA;;;;;iBAgBM,kCAAA;;;;oBAII;WACT;;AA/BN,UAoDY,sCApDI,CAAA,eAoDkD,gBApDlD,CAAA,CAAA;EAAG,YAAA,EAqDR,YArDQ;EAAsB;;;;EAEzC,OAAA,EAyDM,8BAzDsB;EAAgB,gBAAA,EA0D7B,MA1D6B;EAAoB;;;;;EAG/D,UAAA,CAAA,EA8DS,oCA9DT;;AACe,UAgEJ,qCAhEI,CAAA,eAgEiD,gBAhEjD,CAAA,CAAA;EACb;;;EAEE,kBAAA,EAiEY,4BAjEZ,CAiEyC,MAjEzC,CAAA;EACA;;AAgBV;;;EAIoB,QAAA,EAAA,OAAA;EACT;;AAqBX;;;;;EAee,iBAAA,EAAA,OAAA;;AAGf;;;;;AAiCA;;;;;AAIE,iBAJoB,+BAIpB,CAAA,eAJmE,gBAInE,CAAA,CAAA;EAAA,gBAAA;EAAA,OAAA;EAAA,YAAA;EAAA;AAAA,CAAA,EACC,sCADD,CACwC,MADxC,CAAA,CAAA,EACkD,OADlD,CAC0D,qCAD1D,CACgG,MADhG,CAAA,CAAA"}

package/build/utils/credentialUse.mjs

@@ -0,0 +1,117 @@
+
+
+import { CredoError } from "../error/CredoError.mjs";
+import "../agent/index.mjs";
+import { CredentialMultiInstanceState, CredentialMultiInstanceUseMode, CredentialMultiInstanceUseUpdateMode } from "./credentialUseTypes.mjs";
+import { W3cJsonLdVerifiableCredential } from "../modules/vc/data-integrity/models/W3cJsonLdVerifiableCredential.mjs";
+import { W3cV2JwtVerifiableCredential } from "../modules/vc/jwt-vc/W3cV2JwtVerifiableCredential.mjs";
+import { W3cV2SdJwtVerifiableCredential } from "../modules/vc/sd-jwt-vc/W3cV2SdJwtVerifiableCredential.mjs";
+import { W3cJwtVerifiableCredential } from "../modules/vc/jwt-vc/W3cJwtVerifiableCredential.mjs";
+import { W3cCredentialRecord } from "../modules/vc/repository/W3cCredentialRecord.mjs";
+import { W3cCredentialRepository } from "../modules/vc/repository/W3cCredentialRepository.mjs";
+import { W3cV2CredentialRecord } from "../modules/vc/repository/W3cV2CredentialRecord.mjs";
+import { W3cV2CredentialRepository } from "../modules/vc/repository/W3cV2CredentialRepository.mjs";
+import "../modules/vc/repository/index.mjs";
+import "../modules/vc/index.mjs";
+import { Mdoc } from "../modules/mdoc/Mdoc.mjs";
+import { MdocRecord } from "../modules/mdoc/repository/MdocRecord.mjs";
+import { MdocRepository } from "../modules/mdoc/repository/MdocRepository.mjs";
+import "../modules/mdoc/repository/index.mjs";
+import { decodeSdJwtVc } from "../modules/sd-jwt-vc/decodeSdJwtVc.mjs";
+import { SdJwtVcRecord } from "../modules/sd-jwt-vc/repository/SdJwtVcRecord.mjs";
+import { SdJwtVcRepository } from "../modules/sd-jwt-vc/repository/SdJwtVcRepository.mjs";
+import "../modules/sd-jwt-vc/repository/index.mjs";
+
+//#region src/utils/credentialUse.ts
+/**
+* Checks whether an instance can be used from the provided record based on
+* the required credential use mode.
+*/
+function canUseInstanceFromCredentialRecord({ credentialRecord, useMode }) {
+	if (useMode === CredentialMultiInstanceUseMode.First || useMode === CredentialMultiInstanceUseMode.NewOrFirst || useMode === CredentialMultiInstanceUseMode.NewIfReceivedInBatch && [CredentialMultiInstanceState.SingleInstanceUnused, CredentialMultiInstanceState.SingleInstanceUsed].includes(credentialRecord.multiInstanceState)) return true;
+	return credentialRecord.multiInstanceState === CredentialMultiInstanceState.MultiInstanceFirstUnused || credentialRecord.multiInstanceState === CredentialMultiInstanceState.SingleInstanceUnused;
+}
+/**
+* Extract an instance with the correct kms key id from the credential instances
+* on the record. Note that if an instance is extracted (that is not reused) it
+* will remove the instance from the record, and the record should be updated in
+* storage after usage.
+*
+* Note that the last credential instance is never removed from the record. So if the
+* method indicates the last instance has been used, you should remove the credential
+* from storage if you don't want it to be used anymore in the future.
+*/
+async function useInstanceFromCredentialRecord({ credentialRecord, useMode, agentContext, updateMode }) {
+	let extractResult = extractInstanceAndUpdateRecord({
+		credentialRecord,
+		useMode
+	});
+	if ((!extractResult.isReused || extractResult.isLastNewInstance) && updateMode === CredentialMultiInstanceUseUpdateMode.Update) await updateCredentialRecord(agentContext, credentialRecord);
+	if ((!extractResult.isReused || extractResult.isLastNewInstance) && updateMode === CredentialMultiInstanceUseUpdateMode.RefetchAndUpdateWithLock) await repositoryForRecord(agentContext, credentialRecord).updateByIdWithLock(agentContext, credentialRecord.id, async (freshCredentialRecord) => {
+		extractResult = extractInstanceAndUpdateRecord({
+			credentialRecord: freshCredentialRecord,
+			useMode
+		});
+		return freshCredentialRecord;
+	});
+	let transformedCredentialInstance;
+	if (credentialRecord instanceof MdocRecord) {
+		const { issuerSignedBase64Url, kmsKeyId } = extractResult.credentialInstance;
+		transformedCredentialInstance = Mdoc.fromBase64Url(issuerSignedBase64Url);
+		transformedCredentialInstance.deviceKeyId = kmsKeyId ?? transformedCredentialInstance.deviceKey.legacyKeyId;
+	} else if (credentialRecord instanceof SdJwtVcRecord) {
+		const { compactSdJwtVc, kmsKeyId } = extractResult.credentialInstance;
+		transformedCredentialInstance = {
+			...decodeSdJwtVc(compactSdJwtVc, credentialRecord.typeMetadata),
+			kmsKeyId
+		};
+	} else if (credentialRecord instanceof W3cCredentialRecord) {
+		const { credential } = extractResult.credentialInstance;
+		transformedCredentialInstance = typeof credential === "string" ? W3cJwtVerifiableCredential.fromSerializedJwt(credential) : W3cJsonLdVerifiableCredential.fromJson(credential);
+	} else if (credentialRecord instanceof W3cV2CredentialRecord) {
+		const { credential } = extractResult.credentialInstance;
+		transformedCredentialInstance = credential.includes("~") ? W3cV2SdJwtVerifiableCredential.fromCompact(credential) : W3cV2JwtVerifiableCredential.fromCompact(credential);
+	} else throw new CredoError("Unsupported record type");
+	return {
+		credentialInstance: transformedCredentialInstance,
+		isReused: extractResult.isReused,
+		isLastNewInstance: extractResult.isLastNewInstance
+	};
+}
+function extractInstanceAndUpdateRecord({ credentialRecord, useMode }) {
+	if (credentialRecord.credentialInstances.length === 1 || useMode === CredentialMultiInstanceUseMode.First) {
+		const isFirstUnused = credentialRecord.multiInstanceState === CredentialMultiInstanceState.MultiInstanceFirstUnused || credentialRecord.multiInstanceState === CredentialMultiInstanceState.SingleInstanceUnused;
+		const isMultiInstance = credentialRecord.multiInstanceState === CredentialMultiInstanceState.MultiInstanceFirstUnused || credentialRecord.multiInstanceState === CredentialMultiInstanceState.MultiInstanceFirstUsed;
+		const allowsReuse = useMode === CredentialMultiInstanceUseMode.New ? false : useMode === CredentialMultiInstanceUseMode.NewIfReceivedInBatch ? !isMultiInstance : true;
+		if (isFirstUnused) credentialRecord.multiInstanceState = credentialRecord.multiInstanceState === CredentialMultiInstanceState.SingleInstanceUnused ? CredentialMultiInstanceState.SingleInstanceUsed : CredentialMultiInstanceState.MultiInstanceFirstUsed;
+		else if (!allowsReuse) throw new CredoError(`Unable to extract new credential instance from ${credentialRecord.type} with id '${credentialRecord.id}', since it only contains a single credential instance but using a new instance is required due to use mode '${useMode}'.`);
+		return {
+			isReused: !isFirstUnused,
+			credentialInstance: credentialRecord.credentialInstances[0],
+			isLastNewInstance: isFirstUnused
+		};
+	}
+	const _credentialInstance = credentialRecord.credentialInstances.pop();
+	if (!_credentialInstance) throw new CredoError(`Unable to extract credential instance from ${credentialRecord.type} with id '${credentialRecord.id}', since the credential record does not contain any credential instances.`);
+	return {
+		credentialInstance: _credentialInstance,
+		isReused: false,
+		isLastNewInstance: false
+	};
+}
+function repositoryForRecord(agentContext, record) {
+	if (record instanceof W3cCredentialRecord) return agentContext.resolve(W3cCredentialRepository);
+	if (record instanceof W3cV2CredentialRecord) return agentContext.resolve(W3cV2CredentialRepository);
+	if (record instanceof MdocRecord) return agentContext.resolve(MdocRepository);
+	return agentContext.resolve(SdJwtVcRepository);
+}
+function updateCredentialRecord(agentContext, record) {
+	if (record instanceof W3cCredentialRecord) return agentContext.resolve(W3cCredentialRepository).update(agentContext, record);
+	if (record instanceof W3cV2CredentialRecord) return agentContext.resolve(W3cV2CredentialRepository).update(agentContext, record);
+	if (record instanceof MdocRecord) return agentContext.resolve(MdocRepository).update(agentContext, record);
+	return agentContext.resolve(SdJwtVcRepository).update(agentContext, record);
+}
+
+//#endregion
+export { canUseInstanceFromCredentialRecord, useInstanceFromCredentialRecord };
+//# sourceMappingURL=credentialUse.mjs.map

package/build/utils/credentialUse.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentialUse.mjs","names":["transformedCredentialInstance: W3cVerifiableCredential | Mdoc | SdJwtVc | W3cV2VerifiableCredential"],"sources":["../../src/utils/credentialUse.ts"],"sourcesContent":["import { AgentContext } from '../agent'\nimport { CredoError } from '../error/CredoError'\nimport { Mdoc } from '../modules/mdoc/Mdoc'\nimport { MdocRecord, type MdocRecordInstances, MdocRepository } from '../modules/mdoc/repository'\nimport { decodeSdJwtVc } from '../modules/sd-jwt-vc/decodeSdJwtVc'\nimport { SdJwtVcRecord, type SdJwtVcRecordInstances, SdJwtVcRepository } from '../modules/sd-jwt-vc/repository'\nimport type { SdJwtVc } from '../modules/sd-jwt-vc/SdJwtVcService'\nimport {\n  W3cJsonLdVerifiableCredential,\n  W3cJwtVerifiableCredential,\n  W3cV2JwtVerifiableCredential,\n  W3cV2SdJwtVerifiableCredential,\n  type W3cV2VerifiableCredential,\n  type W3cVerifiableCredential,\n} from '../modules/vc'\nimport {\n  W3cCredentialRecord,\n  type W3cCredentialRecordInstances,\n  W3cCredentialRepository,\n  W3cV2CredentialRecord,\n  type W3cV2CredentialRecordInstances,\n  W3cV2CredentialRepository,\n} from '../modules/vc/repository'\nimport {\n  CredentialMultiInstanceState,\n  CredentialMultiInstanceUseMode,\n  CredentialMultiInstanceUseUpdateMode,\n} from './credentialUseTypes'\n\nexport { CredentialMultiInstanceUseMode, CredentialMultiInstanceUseUpdateMode, CredentialMultiInstanceState }\n\ntype CredentialRecord = W3cCredentialRecord | SdJwtVcRecord | MdocRecord | W3cV2CredentialRecord\n\ntype CredentialInstanceReturnType<Record extends CredentialRecord> = Record extends W3cCredentialRecord\n  ? W3cVerifiableCredential\n  : Record extends W3cV2CredentialRecord\n    ? W3cV2VerifiableCredential\n    : Record extends SdJwtVcRecord\n      ? SdJwtVc\n      : Record extends MdocRecord\n        ? Mdoc\n        : CredentialRecord\n\ntype CredentialRepositoryForRecord<Record extends CredentialRecord> = Record extends W3cCredentialRecord\n  ? W3cCredentialRepository\n  : Record extends W3cV2CredentialRepository\n    ? W3cV2VerifiableCredential\n    : Record extends SdJwtVcRepository\n      ? SdJwtVc\n      : Record extends MdocRepository\n        ? Mdoc\n        : W3cCredentialRepository | W3cV2CredentialRepository | SdJwtVcRepository | MdocRepository\n\n/**\n * Checks whether an instance can be used from the provided record based on\n * the required credential use mode.\n */\nexport function canUseInstanceFromCredentialRecord({\n  credentialRecord,\n  useMode,\n}: {\n  credentialRecord: CredentialRecord\n  useMode: CredentialMultiInstanceUseMode\n}) {\n  // If we're not required to use a new instance, we can always return the first instance\n  if (\n    useMode === CredentialMultiInstanceUseMode.First ||\n    useMode === CredentialMultiInstanceUseMode.NewOrFirst ||\n    (useMode === CredentialMultiInstanceUseMode.NewIfReceivedInBatch &&\n      [CredentialMultiInstanceState.SingleInstanceUnused, CredentialMultiInstanceState.SingleInstanceUsed].includes(\n        credentialRecord.multiInstanceState\n      ))\n  ) {\n    return true\n  }\n\n  // Otherwise we return whether we can use a new instance\n  return (\n    credentialRecord.multiInstanceState === CredentialMultiInstanceState.MultiInstanceFirstUnused ||\n    credentialRecord.multiInstanceState === CredentialMultiInstanceState.SingleInstanceUnused\n  )\n}\n\nexport interface UseInstanceFromCredentialRecordOptions<Record extends CredentialRecord> {\n  agentContext: AgentContext\n\n  /**\n   * Which mode to use for usage of the credential instance. See {@link CredentialMultiInstanceUseMode} for\n   * more information on the available options\n   */\n  useMode: CredentialMultiInstanceUseMode\n  credentialRecord: Record\n\n  /**\n   * The update mode for the credential record when a new instance is used.\n   *\n   * @default `CredentialMultiInstanceUseUpdateMode.RefetchAndUpdateWithLock`\n   */\n  updateMode?: CredentialMultiInstanceUseUpdateMode\n}\n\nexport interface UseInstanceFromCredentialRecordReturn<Record extends CredentialRecord> {\n  /**\n   * The credential instance with the kms key id\n   */\n  credentialInstance: CredentialInstanceReturnType<Record>\n\n  /**\n   * If the first instance was used, this value will be `true`. The first time\n   * the first instance is used, technically the credential is not reused yet,\n   * but we make no distinction between this.\n   */\n  isReused: boolean\n\n  /**\n   * Whether the last new instance was used. If `isReused` is `true` this value will\n   * always be `false`.\n   *\n   * The last new instance is the second entry in the mdoc instances, since the first\n   * one is reserved for 'reused' usage.\n   */\n  isLastNewInstance: boolean\n}\n\n/**\n * Extract an instance with the correct kms key id from the credential instances\n * on the record. Note that if an instance is extracted (that is not reused) it\n * will remove the instance from the record, and the record should be updated in\n * storage after usage.\n *\n * Note that the last credential instance is never removed from the record. So if the\n * method indicates the last instance has been used, you should remove the credential\n * from storage if you don't want it to be used anymore in the future.\n */\nexport async function useInstanceFromCredentialRecord<Record extends CredentialRecord>({\n  credentialRecord,\n  useMode,\n  agentContext,\n  updateMode,\n}: UseInstanceFromCredentialRecordOptions<Record>): Promise<UseInstanceFromCredentialRecordReturn<Record>> {\n  let extractResult = extractInstanceAndUpdateRecord({\n    credentialRecord,\n    useMode,\n  })\n\n  if (\n    (!extractResult.isReused || extractResult.isLastNewInstance) &&\n    updateMode === CredentialMultiInstanceUseUpdateMode.Update\n  ) {\n    await updateCredentialRecord(agentContext, credentialRecord)\n  }\n\n  if (\n    (!extractResult.isReused || extractResult.isLastNewInstance) &&\n    updateMode === CredentialMultiInstanceUseUpdateMode.RefetchAndUpdateWithLock\n  ) {\n    // the method is generic, but the types don't work well generically\n    const repository = repositoryForRecord(agentContext, credentialRecord) as SdJwtVcRepository\n\n    await repository.updateByIdWithLock(\n      agentContext,\n      credentialRecord.id,\n      async (freshCredentialRecord: SdJwtVcRecord) => {\n        extractResult = extractInstanceAndUpdateRecord({\n          credentialRecord: freshCredentialRecord,\n          useMode,\n        })\n\n        return freshCredentialRecord\n      }\n    )\n  }\n\n  let transformedCredentialInstance: W3cVerifiableCredential | Mdoc | SdJwtVc | W3cV2VerifiableCredential\n  if (credentialRecord instanceof MdocRecord) {\n    const { issuerSignedBase64Url, kmsKeyId } = extractResult.credentialInstance as MdocRecordInstances[0]\n    transformedCredentialInstance = Mdoc.fromBase64Url(issuerSignedBase64Url)\n    transformedCredentialInstance.deviceKeyId = kmsKeyId ?? transformedCredentialInstance.deviceKey.legacyKeyId\n  } else if (credentialRecord instanceof SdJwtVcRecord) {\n    const { compactSdJwtVc, kmsKeyId } = extractResult.credentialInstance as SdJwtVcRecordInstances[0]\n\n    transformedCredentialInstance = {\n      ...decodeSdJwtVc(compactSdJwtVc, credentialRecord.typeMetadata),\n      kmsKeyId,\n    }\n  } else if (credentialRecord instanceof W3cCredentialRecord) {\n    const { credential } = extractResult.credentialInstance as W3cCredentialRecordInstances[0]\n\n    transformedCredentialInstance =\n      typeof credential === 'string'\n        ? W3cJwtVerifiableCredential.fromSerializedJwt(credential)\n        : W3cJsonLdVerifiableCredential.fromJson(credential)\n  } else if (credentialRecord instanceof W3cV2CredentialRecord) {\n    const { credential } = extractResult.credentialInstance as W3cV2CredentialRecordInstances[0]\n\n    transformedCredentialInstance = credential.includes('~')\n      ? W3cV2SdJwtVerifiableCredential.fromCompact(credential)\n      : W3cV2JwtVerifiableCredential.fromCompact(credential)\n  } else {\n    throw new CredoError('Unsupported record type')\n  }\n\n  return {\n    credentialInstance: transformedCredentialInstance as CredentialInstanceReturnType<Record>,\n    isReused: extractResult.isReused,\n    isLastNewInstance: extractResult.isLastNewInstance,\n  }\n}\n\nfunction extractInstanceAndUpdateRecord<Record extends CredentialRecord>({\n  credentialRecord,\n  useMode,\n}: Pick<UseInstanceFromCredentialRecordOptions<Record>, 'credentialRecord' | 'useMode'>) {\n  if (credentialRecord.credentialInstances.length === 1 || useMode === CredentialMultiInstanceUseMode.First) {\n    const isFirstUnused =\n      credentialRecord.multiInstanceState === CredentialMultiInstanceState.MultiInstanceFirstUnused ||\n      credentialRecord.multiInstanceState === CredentialMultiInstanceState.SingleInstanceUnused\n\n    const isMultiInstance =\n      credentialRecord.multiInstanceState === CredentialMultiInstanceState.MultiInstanceFirstUnused ||\n      credentialRecord.multiInstanceState === CredentialMultiInstanceState.MultiInstanceFirstUsed\n\n    const allowsReuse =\n      // New does not allow reuse\n      useMode === CredentialMultiInstanceUseMode.New\n        ? false\n        : // NewIfReceivedInBatch only allows reuse if the credential was not multi instance\n          useMode === CredentialMultiInstanceUseMode.NewIfReceivedInBatch\n          ? !isMultiInstance\n          : // Otherwise we allow reuse (First or NewOrFirst)\n            true\n\n    if (isFirstUnused) {\n      credentialRecord.multiInstanceState =\n        credentialRecord.multiInstanceState === CredentialMultiInstanceState.SingleInstanceUnused\n          ? CredentialMultiInstanceState.SingleInstanceUsed\n          : CredentialMultiInstanceState.MultiInstanceFirstUsed\n    } else if (!allowsReuse) {\n      throw new CredoError(\n        `Unable to extract new credential instance from ${credentialRecord.type} with id '${credentialRecord.id}', since it only contains a single credential instance but using a new instance is required due to use mode '${useMode}'.`\n      )\n    }\n\n    return {\n      isReused: !isFirstUnused,\n      credentialInstance: credentialRecord.credentialInstances[0],\n      isLastNewInstance: isFirstUnused,\n    }\n  }\n\n  // We have multiple instances, so we pop the last one (never the first one)\n  const _credentialInstance = credentialRecord.credentialInstances.pop()\n  if (!_credentialInstance) {\n    throw new CredoError(\n      `Unable to extract credential instance from ${credentialRecord.type} with id '${credentialRecord.id}', since the credential record does not contain any credential instances.`\n    )\n  }\n\n  return {\n    credentialInstance: _credentialInstance,\n    isReused: false,\n    isLastNewInstance: false,\n  }\n}\n\nfunction repositoryForRecord<Record extends CredentialRecord>(\n  agentContext: AgentContext,\n  record: CredentialRecord\n): CredentialRepositoryForRecord<Record> {\n  if (record instanceof W3cCredentialRecord)\n    return agentContext.resolve(W3cCredentialRepository) as CredentialRepositoryForRecord<Record>\n  if (record instanceof W3cV2CredentialRecord)\n    return agentContext.resolve(W3cV2CredentialRepository) as CredentialRepositoryForRecord<Record>\n  if (record instanceof MdocRecord) return agentContext.resolve(MdocRepository) as CredentialRepositoryForRecord<Record>\n  return agentContext.resolve(SdJwtVcRepository) as CredentialRepositoryForRecord<Record>\n}\n\nfunction updateCredentialRecord(agentContext: AgentContext, record: CredentialRecord) {\n  if (record instanceof W3cCredentialRecord)\n    return agentContext.resolve(W3cCredentialRepository).update(agentContext, record)\n  if (record instanceof W3cV2CredentialRecord)\n    return agentContext.resolve(W3cV2CredentialRepository).update(agentContext, record)\n  if (record instanceof MdocRecord) return agentContext.resolve(MdocRepository).update(agentContext, record)\n  return agentContext.resolve(SdJwtVcRepository).update(agentContext, record)\n}\n"],"mappings":"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"}

package/build/utils/credentialUseTypes.d.mts

@@ -0,0 +1,77 @@
+//#region src/utils/credentialUseTypes.d.ts
+/**
+ * The `CredentialMultiInstanceState` enum represents the state of credential instances on a record.
+ */
+declare enum CredentialMultiInstanceState {
+  /**
+   * Indicates the credential record is a single instance record, and the instance has been used.
+   */
+  SingleInstanceUsed = "SingleInstanceUsed",
+  /**
+   * Indicates the credential record is a single instance record, and the instance has not been used.
+   */
+  SingleInstanceUnused = "SingleInstanceUnused",
+  /**
+   * Indicates the credential record is a multi instance record, where the first instance is used. It may still have other
+   * instances that are unused (which can be detected if the length of credentialInstances > 1)
+   */
+  MultiInstanceFirstUsed = "MultiInstanceFirstUsed",
+  /**
+   * Indicates the credential record is a multi instance record, where the first instance has not been used. It may still have other
+   * instances that are unused (which can be detected if the length of credentialInstances > 1)
+   */
+  MultiInstanceFirstUnused = "MultiInstanceFirstUnused",
+}
+/**
+ * The `CredentialMultiInstanceUseMode` enum offers different modes for usage of credential instances from records.
+ */
+declare enum CredentialMultiInstanceUseMode {
+  /**
+   * Always use a new unused instance. If not available an error will be thrown
+   * that a new instance could not be extracted. This removes the instance from the record.
+   */
+  New = "New",
+  /**
+   * Use a new unused instance if the credential was received as a batch (mimicking behavior of the `CredentialMultiInstanceUseMode.New` mode).
+   * If only a single instance was received it will use the first instance (mimicking behavior of the `CredentialMultiInstanceUseMode.First` mode).
+   */
+  NewIfReceivedInBatch = "NewIfReceivedInBatch",
+  /**
+   * use a new unused instance if available, or fallback to the
+   * first one if not available. This is a combination of the `first` and `new` modes, and the same
+   * behavior applies (in terms of whether the instance is removed from the record).
+   */
+  NewOrFirst = "NewOrFirst",
+  /**
+   * Always use the first credential instance on the record. This does not remove
+   * the credential instance from the record, and it also does not prevent reusing.
+   */
+  First = "First",
+}
+declare enum CredentialMultiInstanceUseUpdateMode {
+  /**
+   * The record is not updated, which means the credential can be reused in the future even
+   * if `useMode` is set to `New`. This is generally not recommended.
+   */
+  None = "None",
+  /**
+   * Update the provided record if a new instance is used. This may result in race conditions
+   * if multiple processes are using the record at the same time (e.g. in a server environment)
+   */
+  Update = "Update",
+  /**
+   * Refetch and update the provided record with a lock. This is the safest method, but does
+   * require another re-fetch of the record. Locking is not supported on all databases backend,
+   * in which case the record will be refetched and updated without lock.
+   *
+   * Even without lock, this will still minimize the chance of race conditions and concurrent writes significantly, as
+   * with the standard `Update` the record was fetched at the time the credentials were received, which is usually before
+   * showing the request to the user and waiting for confirmation.
+   *
+   * This is the recommended option.
+   */
+  RefetchAndUpdateWithLock = "RefetchAndUpdateWithLock",
+}
+//#endregion
+export { CredentialMultiInstanceState, CredentialMultiInstanceUseMode, CredentialMultiInstanceUseUpdateMode };
+//# sourceMappingURL=credentialUseTypes.d.mts.map

package/build/utils/credentialUseTypes.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentialUseTypes.d.mts","names":[],"sources":["../../src/utils/credentialUseTypes.ts"],"sourcesContent":[],"mappings":";;;;AAGY,aAAA,4BAAA;EA2BA;AA2BZ;;;;;;;;;;;;;;;;;;;;;aA3BY,8BAAA;;;;;;;;;;;;;;;;;;;;;;;aA2BA,oCAAA"}

package/build/utils/credentialUseTypes.mjs

@@ -0,0 +1,83 @@
+
+
+//#region src/utils/credentialUseTypes.ts
+/**
+* The `CredentialMultiInstanceState` enum represents the state of credential instances on a record.
+*/
+let CredentialMultiInstanceState = /* @__PURE__ */ function(CredentialMultiInstanceState$1) {
+	/**
+	* Indicates the credential record is a single instance record, and the instance has been used.
+	*/
+	CredentialMultiInstanceState$1["SingleInstanceUsed"] = "SingleInstanceUsed";
+	/**
+	* Indicates the credential record is a single instance record, and the instance has not been used.
+	*/
+	CredentialMultiInstanceState$1["SingleInstanceUnused"] = "SingleInstanceUnused";
+	/**
+	* Indicates the credential record is a multi instance record, where the first instance is used. It may still have other
+	* instances that are unused (which can be detected if the length of credentialInstances > 1)
+	*/
+	CredentialMultiInstanceState$1["MultiInstanceFirstUsed"] = "MultiInstanceFirstUsed";
+	/**
+	* Indicates the credential record is a multi instance record, where the first instance has not been used. It may still have other
+	* instances that are unused (which can be detected if the length of credentialInstances > 1)
+	*/
+	CredentialMultiInstanceState$1["MultiInstanceFirstUnused"] = "MultiInstanceFirstUnused";
+	return CredentialMultiInstanceState$1;
+}({});
+/**
+* The `CredentialMultiInstanceUseMode` enum offers different modes for usage of credential instances from records.
+*/
+let CredentialMultiInstanceUseMode = /* @__PURE__ */ function(CredentialMultiInstanceUseMode$1) {
+	/**
+	* Always use a new unused instance. If not available an error will be thrown
+	* that a new instance could not be extracted. This removes the instance from the record.
+	*/
+	CredentialMultiInstanceUseMode$1["New"] = "New";
+	/**
+	* Use a new unused instance if the credential was received as a batch (mimicking behavior of the `CredentialMultiInstanceUseMode.New` mode).
+	* If only a single instance was received it will use the first instance (mimicking behavior of the `CredentialMultiInstanceUseMode.First` mode).
+	*/
+	CredentialMultiInstanceUseMode$1["NewIfReceivedInBatch"] = "NewIfReceivedInBatch";
+	/**
+	* use a new unused instance if available, or fallback to the
+	* first one if not available. This is a combination of the `first` and `new` modes, and the same
+	* behavior applies (in terms of whether the instance is removed from the record).
+	*/
+	CredentialMultiInstanceUseMode$1["NewOrFirst"] = "NewOrFirst";
+	/**
+	* Always use the first credential instance on the record. This does not remove
+	* the credential instance from the record, and it also does not prevent reusing.
+	*/
+	CredentialMultiInstanceUseMode$1["First"] = "First";
+	return CredentialMultiInstanceUseMode$1;
+}({});
+let CredentialMultiInstanceUseUpdateMode = /* @__PURE__ */ function(CredentialMultiInstanceUseUpdateMode$1) {
+	/**
+	* The record is not updated, which means the credential can be reused in the future even
+	* if `useMode` is set to `New`. This is generally not recommended.
+	*/
+	CredentialMultiInstanceUseUpdateMode$1["None"] = "None";
+	/**
+	* Update the provided record if a new instance is used. This may result in race conditions
+	* if multiple processes are using the record at the same time (e.g. in a server environment)
+	*/
+	CredentialMultiInstanceUseUpdateMode$1["Update"] = "Update";
+	/**
+	* Refetch and update the provided record with a lock. This is the safest method, but does
+	* require another re-fetch of the record. Locking is not supported on all databases backend,
+	* in which case the record will be refetched and updated without lock.
+	*
+	* Even without lock, this will still minimize the chance of race conditions and concurrent writes significantly, as
+	* with the standard `Update` the record was fetched at the time the credentials were received, which is usually before
+	* showing the request to the user and waiting for confirmation.
+	*
+	* This is the recommended option.
+	*/
+	CredentialMultiInstanceUseUpdateMode$1["RefetchAndUpdateWithLock"] = "RefetchAndUpdateWithLock";
+	return CredentialMultiInstanceUseUpdateMode$1;
+}({});
+
+//#endregion
+export { CredentialMultiInstanceState, CredentialMultiInstanceUseMode, CredentialMultiInstanceUseUpdateMode };
+//# sourceMappingURL=credentialUseTypes.mjs.map

package/build/utils/credentialUseTypes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentialUseTypes.mjs","names":[],"sources":["../../src/utils/credentialUseTypes.ts"],"sourcesContent":["/**\n * The `CredentialMultiInstanceState` enum represents the state of credential instances on a record.\n */\nexport enum CredentialMultiInstanceState {\n  /**\n   * Indicates the credential record is a single instance record, and the instance has been used.\n   */\n  SingleInstanceUsed = 'SingleInstanceUsed',\n\n  /**\n   * Indicates the credential record is a single instance record, and the instance has not been used.\n   */\n  SingleInstanceUnused = 'SingleInstanceUnused',\n\n  /**\n   * Indicates the credential record is a multi instance record, where the first instance is used. It may still have other\n   * instances that are unused (which can be detected if the length of credentialInstances > 1)\n   */\n  MultiInstanceFirstUsed = 'MultiInstanceFirstUsed',\n\n  /**\n   * Indicates the credential record is a multi instance record, where the first instance has not been used. It may still have other\n   * instances that are unused (which can be detected if the length of credentialInstances > 1)\n   */\n  MultiInstanceFirstUnused = 'MultiInstanceFirstUnused',\n}\n\n/**\n * The `CredentialMultiInstanceUseMode` enum offers different modes for usage of credential instances from records.\n */\nexport enum CredentialMultiInstanceUseMode {\n  /**\n   * Always use a new unused instance. If not available an error will be thrown\n   * that a new instance could not be extracted. This removes the instance from the record.\n   */\n  New = 'New',\n\n  /**\n   * Use a new unused instance if the credential was received as a batch (mimicking behavior of the `CredentialMultiInstanceUseMode.New` mode).\n   * If only a single instance was received it will use the first instance (mimicking behavior of the `CredentialMultiInstanceUseMode.First` mode).\n   */\n  NewIfReceivedInBatch = 'NewIfReceivedInBatch',\n\n  /**\n   * use a new unused instance if available, or fallback to the\n   * first one if not available. This is a combination of the `first` and `new` modes, and the same\n   * behavior applies (in terms of whether the instance is removed from the record).\n   */\n  NewOrFirst = 'NewOrFirst',\n\n  /**\n   * Always use the first credential instance on the record. This does not remove\n   * the credential instance from the record, and it also does not prevent reusing.\n   */\n  First = 'First',\n}\n\nexport enum CredentialMultiInstanceUseUpdateMode {\n  /**\n   * The record is not updated, which means the credential can be reused in the future even\n   * if `useMode` is set to `New`. This is generally not recommended.\n   */\n  None = 'None',\n\n  /**\n   * Update the provided record if a new instance is used. This may result in race conditions\n   * if multiple processes are using the record at the same time (e.g. in a server environment)\n   */\n  Update = 'Update',\n\n  /**\n   * Refetch and update the provided record with a lock. This is the safest method, but does\n   * require another re-fetch of the record. Locking is not supported on all databases backend,\n   * in which case the record will be refetched and updated without lock.\n   *\n   * Even without lock, this will still minimize the chance of race conditions and concurrent writes significantly, as\n   * with the standard `Update` the record was fetched at the time the credentials were received, which is usually before\n   * showing the request to the user and waiting for confirmation.\n   *\n   * This is the recommended option.\n   */\n  RefetchAndUpdateWithLock = 'RefetchAndUpdateWithLock',\n}\n"],"mappings":";;;;;;AAGA,IAAY,wFAAL;;;;AAIL;;;;AAKA;;;;;AAMA;;;;;AAMA;;;;;;AAMF,IAAY,4FAAL;;;;;AAKL;;;;;AAMA;;;;;;AAOA;;;;;AAMA;;;AAGF,IAAY,wGAAL;;;;;AAKL;;;;;AAMA;;;;;;;;;;;;AAaA"}

package/build/utils/deepEquality.d.mts

@@ -0,0 +1,13 @@
+//#region src/utils/deepEquality.d.ts
+declare function deepEquality(x: any, y: any): boolean;
+/**
+ * @note This will only work for primitive array equality
+ */
+declare function equalsIgnoreOrder<Item = string>(a: Array<Item>, b: Array<Item>): boolean;
+/**
+ * @note This will only work for primitive array equality
+ */
+declare function equalsWithOrder<Item = string>(lhs: Array<Item>, rhs: Array<Item>): boolean;
+//#endregion
+export { deepEquality, equalsIgnoreOrder, equalsWithOrder };
+//# sourceMappingURL=deepEquality.d.mts.map

package/build/utils/deepEquality.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepEquality.d.mts","names":[],"sources":["../../src/utils/deepEquality.ts"],"sourcesContent":[],"mappings":";iBAGgB,YAAA;;;AAAhB;AAyBgB,iBAAA,iBAAiB,CAAA,OAAA,MAAA,CAAA,CAAA,CAAA,EAAmB,KAAnB,CAAyB,IAAzB,CAAA,EAAA,CAAA,EAAmC,KAAnC,CAAyC,IAAzC,CAAA,CAAA,EAAA,OAAA;;;;AAAmC,iBAQpD,eARoD,CAAA,OAAA,MAAA,CAAA,CAAA,GAAA,EAQhB,KARgB,CAQV,IARU,CAAA,EAAA,GAAA,EAQE,KARF,CAQQ,IARR,CAAA,CAAA,EAAA,OAAA"}

package/build/utils/deepEquality.mjs

@@ -0,0 +1,41 @@
+
+
+import { areObjectsEqual } from "./objectEquality.mjs";
+
+//#region src/utils/deepEquality.ts
+function deepEquality(x, y) {
+	const isXSimpleEqualY = simpleEqual(x, y);
+	if (isXSimpleEqualY !== void 0) return isXSimpleEqualY;
+	if (!(x instanceof Map) || !(y instanceof Map)) return areObjectsEqual(x, y);
+	const xMap = x;
+	const yMap = y;
+	if (!equalsIgnoreOrder(Array.from(xMap.keys()), Array.from(yMap.keys()))) return false;
+	return Array.from(xMap.entries()).every(([key, xVal]) => deepEquality(xVal, yMap.get(key)));
+}
+/**
+* @note This will only work for primitive array equality
+*/
+function equalsIgnoreOrder(a, b) {
+	if (a.length !== b.length) return false;
+	return a.every((k) => b.includes(k));
+}
+/**
+* @note This will only work for primitive array equality
+*/
+function equalsWithOrder(lhs, rhs) {
+	if (lhs.length !== rhs.length) return false;
+	return lhs.every((k, i) => k === rhs[i]);
+}
+function simpleEqual(x, y) {
+	if (x === y) return true;
+	if ((x === null || x === void 0) && (y === null || y === void 0)) return x === y;
+	if (x.constructor !== y.constructor) return false;
+	if (x instanceof Function) return x === y;
+	if (x instanceof RegExp) return x === y;
+	if (x.valueOf && y.valueOf && x.valueOf() === y.valueOf()) return true;
+	if (x instanceof Date || y instanceof Date) return false;
+}
+
+//#endregion
+export { deepEquality, equalsIgnoreOrder, equalsWithOrder };
+//# sourceMappingURL=deepEquality.mjs.map

package/build/utils/deepEquality.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepEquality.mjs","names":[],"sources":["../../src/utils/deepEquality.ts"],"sourcesContent":["import { areObjectsEqual } from './objectEquality'\n\n// biome-ignore lint/suspicious/noExplicitAny: no explanation\nexport function deepEquality(x: any, y: any): boolean {\n  // We do a simple equals here to check primitives, functions, regex, etc.\n  // This will only happen if the typing of the function is ignored\n  const isXSimpleEqualY = simpleEqual(x, y)\n  if (isXSimpleEqualY !== undefined) return isXSimpleEqualY\n\n  if (!(x instanceof Map) || !(y instanceof Map)) return areObjectsEqual(x, y)\n\n  const xMap = x as Map<string, unknown>\n  const yMap = y as Map<string, unknown>\n\n  // At this point we are sure we have two instances of a Map\n  const xKeys = Array.from(xMap.keys())\n  const yKeys = Array.from(yMap.keys())\n\n  // Keys from both maps are not equal, content has not been verified, yet\n  if (!equalsIgnoreOrder(xKeys, yKeys)) return false\n\n  // Here we recursively check whether the value of xMap is equals to the value of yMap\n  return Array.from(xMap.entries()).every(([key, xVal]) => deepEquality(xVal, yMap.get(key)))\n}\n\n/**\n * @note This will only work for primitive array equality\n */\nexport function equalsIgnoreOrder<Item = string>(a: Array<Item>, b: Array<Item>): boolean {\n  if (a.length !== b.length) return false\n  return a.every((k) => b.includes(k))\n}\n\n/**\n * @note This will only work for primitive array equality\n */\nexport function equalsWithOrder<Item = string>(lhs: Array<Item>, rhs: Array<Item>): boolean {\n  if (lhs.length !== rhs.length) return false\n  return lhs.every((k, i) => k === rhs[i])\n}\n\n// We take any here as we have to check some properties, they will be undefined if they do not exist\n// biome-ignore lint/suspicious/noExplicitAny: no explanation\nfunction simpleEqual(x: any, y: any) {\n  // short circuit for easy equality\n  if (x === y) return true\n\n  if ((x === null || x === undefined) && (y === null || y === undefined)) return x === y\n\n  // after this just checking type of one would be enough\n  if (x.constructor !== y.constructor) return false\n\n  // if they are functions, they should exactly refer to same one (because of closures)\n  if (x instanceof Function) return x === y\n\n  // if they are regexps, they should exactly refer to same one (it is hard to better equality check on current ES)\n  if (x instanceof RegExp) return x === y\n\n  if (x.valueOf && y.valueOf && x.valueOf() === y.valueOf()) return true\n\n  // if they are dates, they must had equal valueOf\n  if (x instanceof Date || y instanceof Date) return false\n}\n"],"mappings":";;;;;AAGA,SAAgB,aAAa,GAAQ,GAAiB;CAGpD,MAAM,kBAAkB,YAAY,GAAG,EAAE;AACzC,KAAI,oBAAoB,OAAW,QAAO;AAE1C,KAAI,EAAE,aAAa,QAAQ,EAAE,aAAa,KAAM,QAAO,gBAAgB,GAAG,EAAE;CAE5E,MAAM,OAAO;CACb,MAAM,OAAO;AAOb,KAAI,CAAC,kBAJS,MAAM,KAAK,KAAK,MAAM,CAAC,EACvB,MAAM,KAAK,KAAK,MAAM,CAAC,CAGD,CAAE,QAAO;AAG7C,QAAO,MAAM,KAAK,KAAK,SAAS,CAAC,CAAC,OAAO,CAAC,KAAK,UAAU,aAAa,MAAM,KAAK,IAAI,IAAI,CAAC,CAAC;;;;;AAM7F,SAAgB,kBAAiC,GAAgB,GAAyB;AACxF,KAAI,EAAE,WAAW,EAAE,OAAQ,QAAO;AAClC,QAAO,EAAE,OAAO,MAAM,EAAE,SAAS,EAAE,CAAC;;;;;AAMtC,SAAgB,gBAA+B,KAAkB,KAA2B;AAC1F,KAAI,IAAI,WAAW,IAAI,OAAQ,QAAO;AACtC,QAAO,IAAI,OAAO,GAAG,MAAM,MAAM,IAAI,GAAG;;AAK1C,SAAS,YAAY,GAAQ,GAAQ;AAEnC,KAAI,MAAM,EAAG,QAAO;AAEpB,MAAK,MAAM,QAAQ,MAAM,YAAe,MAAM,QAAQ,MAAM,QAAY,QAAO,MAAM;AAGrF,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;AAG5C,KAAI,aAAa,SAAU,QAAO,MAAM;AAGxC,KAAI,aAAa,OAAQ,QAAO,MAAM;AAEtC,KAAI,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,KAAK,EAAE,SAAS,CAAE,QAAO;AAGlE,KAAI,aAAa,QAAQ,aAAa,KAAM,QAAO"}

package/build/utils/did.d.mts

@@ -0,0 +1,13 @@
+//#region src/utils/did.d.ts
+declare function indyDidFromPublicKeyBase58(publicKeyBase58: string): string;
+/**
+ * Checks whether `potentialDid` is a valid DID. You can optionally provide a `method` to
+ * check whether the did is for that specific method.
+ *
+ * Note: the check in this method is very simple and just check whether the did starts with
+ * `did:` or `did:<method>:`. It does not do an advanced regex check on the did.
+ */
+declare function isDid(potentialDid: string, method?: string): boolean;
+//#endregion
+export { indyDidFromPublicKeyBase58, isDid };
+//# sourceMappingURL=did.d.mts.map

package/build/utils/did.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"did.d.mts","names":[],"sources":["../../src/utils/did.ts"],"sourcesContent":[],"mappings":";iBAEgB,0BAAA;;;AAAhB;AAeA;;;;iBAAgB,KAAA"}

package/build/utils/did.mjs

@@ -0,0 +1,23 @@
+
+
+import { TypedArrayEncoder } from "./TypedArrayEncoder.mjs";
+
+//#region src/utils/did.ts
+function indyDidFromPublicKeyBase58(publicKeyBase58) {
+	const buffer = TypedArrayEncoder.fromBase58(publicKeyBase58);
+	return TypedArrayEncoder.toBase58(buffer.slice(0, 16));
+}
+/**
+* Checks whether `potentialDid` is a valid DID. You can optionally provide a `method` to
+* check whether the did is for that specific method.
+*
+* Note: the check in this method is very simple and just check whether the did starts with
+* `did:` or `did:<method>:`. It does not do an advanced regex check on the did.
+*/
+function isDid(potentialDid, method) {
+	return method ? potentialDid.startsWith(`did:${method}:`) : potentialDid.startsWith("did:");
+}
+
+//#endregion
+export { indyDidFromPublicKeyBase58, isDid };
+//# sourceMappingURL=did.mjs.map

package/build/utils/did.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"did.mjs","names":[],"sources":["../../src/utils/did.ts"],"sourcesContent":["import { TypedArrayEncoder } from './TypedArrayEncoder'\n\nexport function indyDidFromPublicKeyBase58(publicKeyBase58: string): string {\n  const buffer = TypedArrayEncoder.fromBase58(publicKeyBase58)\n\n  const did = TypedArrayEncoder.toBase58(buffer.slice(0, 16))\n\n  return did\n}\n\n/**\n * Checks whether `potentialDid` is a valid DID. You can optionally provide a `method` to\n * check whether the did is for that specific method.\n *\n * Note: the check in this method is very simple and just check whether the did starts with\n * `did:` or `did:<method>:`. It does not do an advanced regex check on the did.\n */\nexport function isDid(potentialDid: string, method?: string) {\n  return method ? potentialDid.startsWith(`did:${method}:`) : potentialDid.startsWith('did:')\n}\n"],"mappings":";;;;;AAEA,SAAgB,2BAA2B,iBAAiC;CAC1E,MAAM,SAAS,kBAAkB,WAAW,gBAAgB;AAI5D,QAFY,kBAAkB,SAAS,OAAO,MAAM,GAAG,GAAG,CAAC;;;;;;;;;AAY7D,SAAgB,MAAM,cAAsB,QAAiB;AAC3D,QAAO,SAAS,aAAa,WAAW,OAAO,OAAO,GAAG,GAAG,aAAa,WAAW,OAAO"}

package/build/utils/domain.d.mts

@@ -0,0 +1,5 @@
+//#region src/utils/domain.d.ts
+declare function getDomainFromUrl(url: string): string;
+//#endregion
+export { getDomainFromUrl };
+//# sourceMappingURL=domain.d.mts.map

package/build/utils/domain.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.mts","names":[],"sources":["../../src/utils/domain.ts"],"sourcesContent":[],"mappings":";iBAAgB,gBAAA"}