internxt-crypto 0.0.14 → 1.0.1

package/dist/keys-BfcaiAOv.mjs

@@ -1,90 +0,0 @@
-import { AES_KEY_BIT_LENGTH, ECC_ALGORITHM } from "./constants.mjs";
-
-//#region src/asymmetric-crypto/ellipticCurve.ts
-/**
-* Derives secret key from the other user's public key and own private key
-*
-* @param otherUserPublicKey - The public key of the other user
-* @param ownPrivateKey - The private key
-* @returns The derived secret key bits
-*/
-async function deriveSecretKey(otherUserPublicKey, ownPrivateKey) {
-	try {
-		const result = await crypto.subtle.deriveBits({
-			name: ECC_ALGORITHM,
-			public: otherUserPublicKey
-		}, ownPrivateKey, AES_KEY_BIT_LENGTH);
-		return new Uint8Array(result);
-	} catch (error) {
-		throw new Error("Failed to derive elliptic curve secret key", { cause: error });
-	}
-}
-
-//#endregion
-//#region src/asymmetric-crypto/keys.ts
-/**
-* Generates elliptic curve key pair
-*
-* @returns The generated key pair
-*/
-async function generateEccKeys() {
-	try {
-		return await crypto.subtle.generateKey({ name: ECC_ALGORITHM }, true, ["deriveBits"]);
-	} catch (error) {
-		throw new Error("Failed to generate elliptic curve key pair", { cause: error });
-	}
-}
-/**
-* Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)
-*
-* @returns The Uint8Array representation of the public key
-*/
-async function exportPublicKey(key) {
-	try {
-		const result = await crypto.subtle.exportKey("spki", key);
-		return new Uint8Array(result);
-	} catch (error) {
-		throw new Error("Failed to export public key", { cause: error });
-	}
-}
-/**
-* Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey
-*
-* @returns The CryptoKey representation of the public key
-*/
-async function importPublicKey(spkiKeyData) {
-	try {
-		return await crypto.subtle.importKey("spki", spkiKeyData, { name: ECC_ALGORITHM }, true, []);
-	} catch (error) {
-		throw new Error("Failed to import public key", { cause: error });
-	}
-}
-/**
-* Converts private key in CryptoKey to PKCS #8 format (RFC 5208)
-*
-* @returns The Uint8Array representation of the private key
-*/
-async function exportPrivateKey(key) {
-	try {
-		const result = await crypto.subtle.exportKey("pkcs8", key);
-		return new Uint8Array(result);
-	} catch (error) {
-		throw new Error("Failed to export private key", { cause: error });
-	}
-}
-/**
-* Converts private key in PKCS #8 format (RFC 5208) to CryptoKey
-*
-* @returns The CryptoKey representation of the private key
-*/
-async function importPrivateKey(pkcs8KeyData) {
-	try {
-		return await crypto.subtle.importKey("pkcs8", pkcs8KeyData, { name: ECC_ALGORITHM }, true, ["deriveBits"]);
-	} catch (error) {
-		throw new Error("Failed to import private key", { cause: error });
-	}
-}
-
-//#endregion
-export { importPublicKey as a, importPrivateKey as i, exportPublicKey as n, deriveSecretKey as o, generateEccKeys as r, exportPrivateKey as t };
-//# sourceMappingURL=keys-BfcaiAOv.mjs.map

package/dist/keys-BfcaiAOv.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"keys-BfcaiAOv.mjs","names":[],"sources":["../src/asymmetric-crypto/ellipticCurve.ts","../src/asymmetric-crypto/keys.ts"],"sourcesContent":["import { ECC_ALGORITHM, AES_KEY_BIT_LENGTH } from '../constants';\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param otherUserPublicKey - The public key of the other user\n * @param ownPrivateKey - The private key\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(otherUserPublicKey: CryptoKey, ownPrivateKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.deriveBits(\n      {\n        name: ECC_ALGORITHM,\n        public: otherUserPublicKey,\n      },\n      ownPrivateKey,\n      AES_KEY_BIT_LENGTH,\n    );\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n","import { ECC_ALGORITHM } from '../constants';\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<CryptoKeyPair> {\n  try {\n    return (await crypto.subtle.generateKey(\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    )) as CryptoKeyPair;\n  } catch (error) {\n    throw new Error('Failed to generate elliptic curve key pair', { cause: error });\n  }\n}\n\n/**\n * Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)\n *\n * @returns The Uint8Array representation of the public key\n */\nexport async function exportPublicKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('spki', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export public key', { cause: error });\n  }\n}\n\n/**\n * Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey\n *\n * @returns The CryptoKey representation of the public key\n */\nexport async function importPublicKey(spkiKeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'spki',\n      spkiKeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      [],\n    );\n  } catch (error) {\n    throw new Error('Failed to import public key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in CryptoKey to PKCS #8 format (RFC 5208)\n *\n * @returns The Uint8Array representation of the private key\n */\nexport async function exportPrivateKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('pkcs8', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export private key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in PKCS #8 format (RFC 5208) to CryptoKey\n *\n * @returns The CryptoKey representation of the private key\n */\nexport async function importPrivateKey(pkcs8KeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'pkcs8',\n      pkcs8KeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    );\n  } catch (error) {\n    throw new Error('Failed to import private key', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,eAAsB,gBAAgB,oBAA+B,eAA+C;AAClH,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,WACjC;GACE,MAAM;GACN,QAAQ;GACT,EACD,eACA,mBACD;AACD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACdnF,eAAsB,kBAA0C;AAC9D,KAAI;AACF,SAAQ,MAAM,OAAO,OAAO,YAC1B,EACE,MAAM,eACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,gBAAgB,KAAqC;AACzE,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,QAAQ,IAAI;AACzD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,gBAAgB,aAA6C;AACjF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,QACA,aACA,EACE,MAAM,eACP,EACD,MACA,EAAE,CACH;UACM,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,iBAAiB,KAAqC;AAC1E,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,SAAS,IAAI;AAC1D,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASrE,eAAsB,iBAAiB,cAA8C;AACnF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,SACA,cACA,EACE,MAAM,eACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC"}

package/dist/keys-CinT7kEY.js

@@ -1,125 +0,0 @@
-const require_constants = require('./constants.js');
-
-//#region src/asymmetric-crypto/ellipticCurve.ts
-/**
-* Derives secret key from the other user's public key and own private key
-*
-* @param otherUserPublicKey - The public key of the other user
-* @param ownPrivateKey - The private key
-* @returns The derived secret key bits
-*/
-async function deriveSecretKey(otherUserPublicKey, ownPrivateKey) {
-	try {
-		const result = await crypto.subtle.deriveBits({
-			name: require_constants.ECC_ALGORITHM,
-			public: otherUserPublicKey
-		}, ownPrivateKey, require_constants.AES_KEY_BIT_LENGTH);
-		return new Uint8Array(result);
-	} catch (error) {
-		throw new Error("Failed to derive elliptic curve secret key", { cause: error });
-	}
-}
-
-//#endregion
-//#region src/asymmetric-crypto/keys.ts
-/**
-* Generates elliptic curve key pair
-*
-* @returns The generated key pair
-*/
-async function generateEccKeys() {
-	try {
-		return await crypto.subtle.generateKey({ name: require_constants.ECC_ALGORITHM }, true, ["deriveBits"]);
-	} catch (error) {
-		throw new Error("Failed to generate elliptic curve key pair", { cause: error });
-	}
-}
-/**
-* Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)
-*
-* @returns The Uint8Array representation of the public key
-*/
-async function exportPublicKey(key) {
-	try {
-		const result = await crypto.subtle.exportKey("spki", key);
-		return new Uint8Array(result);
-	} catch (error) {
-		throw new Error("Failed to export public key", { cause: error });
-	}
-}
-/**
-* Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey
-*
-* @returns The CryptoKey representation of the public key
-*/
-async function importPublicKey(spkiKeyData) {
-	try {
-		return await crypto.subtle.importKey("spki", spkiKeyData, { name: require_constants.ECC_ALGORITHM }, true, []);
-	} catch (error) {
-		throw new Error("Failed to import public key", { cause: error });
-	}
-}
-/**
-* Converts private key in CryptoKey to PKCS #8 format (RFC 5208)
-*
-* @returns The Uint8Array representation of the private key
-*/
-async function exportPrivateKey(key) {
-	try {
-		const result = await crypto.subtle.exportKey("pkcs8", key);
-		return new Uint8Array(result);
-	} catch (error) {
-		throw new Error("Failed to export private key", { cause: error });
-	}
-}
-/**
-* Converts private key in PKCS #8 format (RFC 5208) to CryptoKey
-*
-* @returns The CryptoKey representation of the private key
-*/
-async function importPrivateKey(pkcs8KeyData) {
-	try {
-		return await crypto.subtle.importKey("pkcs8", pkcs8KeyData, { name: require_constants.ECC_ALGORITHM }, true, ["deriveBits"]);
-	} catch (error) {
-		throw new Error("Failed to import private key", { cause: error });
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'deriveSecretKey', {
-  enumerable: true,
-  get: function () {
-    return deriveSecretKey;
-  }
-});
-Object.defineProperty(exports, 'exportPrivateKey', {
-  enumerable: true,
-  get: function () {
-    return exportPrivateKey;
-  }
-});
-Object.defineProperty(exports, 'exportPublicKey', {
-  enumerable: true,
-  get: function () {
-    return exportPublicKey;
-  }
-});
-Object.defineProperty(exports, 'generateEccKeys', {
-  enumerable: true,
-  get: function () {
-    return generateEccKeys;
-  }
-});
-Object.defineProperty(exports, 'importPrivateKey', {
-  enumerable: true,
-  get: function () {
-    return importPrivateKey;
-  }
-});
-Object.defineProperty(exports, 'importPublicKey', {
-  enumerable: true,
-  get: function () {
-    return importPublicKey;
-  }
-});
-//# sourceMappingURL=keys-CinT7kEY.js.map

package/dist/keys-CinT7kEY.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"keys-CinT7kEY.js","names":["ECC_ALGORITHM","AES_KEY_BIT_LENGTH","ECC_ALGORITHM"],"sources":["../src/asymmetric-crypto/ellipticCurve.ts","../src/asymmetric-crypto/keys.ts"],"sourcesContent":["import { ECC_ALGORITHM, AES_KEY_BIT_LENGTH } from '../constants';\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param otherUserPublicKey - The public key of the other user\n * @param ownPrivateKey - The private key\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(otherUserPublicKey: CryptoKey, ownPrivateKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.deriveBits(\n      {\n        name: ECC_ALGORITHM,\n        public: otherUserPublicKey,\n      },\n      ownPrivateKey,\n      AES_KEY_BIT_LENGTH,\n    );\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n","import { ECC_ALGORITHM } from '../constants';\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<CryptoKeyPair> {\n  try {\n    return (await crypto.subtle.generateKey(\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    )) as CryptoKeyPair;\n  } catch (error) {\n    throw new Error('Failed to generate elliptic curve key pair', { cause: error });\n  }\n}\n\n/**\n * Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)\n *\n * @returns The Uint8Array representation of the public key\n */\nexport async function exportPublicKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('spki', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export public key', { cause: error });\n  }\n}\n\n/**\n * Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey\n *\n * @returns The CryptoKey representation of the public key\n */\nexport async function importPublicKey(spkiKeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'spki',\n      spkiKeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      [],\n    );\n  } catch (error) {\n    throw new Error('Failed to import public key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in CryptoKey to PKCS #8 format (RFC 5208)\n *\n * @returns The Uint8Array representation of the private key\n */\nexport async function exportPrivateKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('pkcs8', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export private key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in PKCS #8 format (RFC 5208) to CryptoKey\n *\n * @returns The CryptoKey representation of the private key\n */\nexport async function importPrivateKey(pkcs8KeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'pkcs8',\n      pkcs8KeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    );\n  } catch (error) {\n    throw new Error('Failed to import private key', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,eAAsB,gBAAgB,oBAA+B,eAA+C;AAClH,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,WACjC;GACE,MAAMA;GACN,QAAQ;GACT,EACD,eACAC,qCACD;AACD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACdnF,eAAsB,kBAA0C;AAC9D,KAAI;AACF,SAAQ,MAAM,OAAO,OAAO,YAC1B,EACE,MAAMC,iCACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,gBAAgB,KAAqC;AACzE,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,QAAQ,IAAI;AACzD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,gBAAgB,aAA6C;AACjF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,QACA,aACA,EACE,MAAMA,iCACP,EACD,MACA,EAAE,CACH;UACM,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,iBAAiB,KAAqC;AAC1E,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,SAAS,IAAI;AAC1D,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASrE,eAAsB,iBAAiB,cAA8C;AACnF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,SACA,cACA,EACE,MAAMA,iCACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC"}

package/dist/kyber768-SXnIo-Nw.mjs

@@ -1,47 +0,0 @@
-import { ml_kem768 } from "@noble/post-quantum/ml-kem.js";
-
-//#region src/post-quantum-crypto/kyber768.ts
-/**
-* Generates public and secret Kyber keys
-*
-* @param seed - The optional seed
-* @returns The generated Kyber key pair.
-*/
-function generateKyberKeys(seed) {
-	try {
-		return ml_kem768.keygen(seed);
-	} catch (error) {
-		throw new Error("Failed to generate Kyber keys", { cause: error });
-	}
-}
-/**
-* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
-*
-* @param publicKey - The public Kyber key
-* @returns The resulting encapsulation and the generated shared secret.
-*/
-function encapsulateKyber(publicKey) {
-	try {
-		return ml_kem768.encapsulate(publicKey);
-	} catch (error) {
-		throw new Error("Failed to encapsulate", { cause: error });
-	}
-}
-/**
-* Decapsulates the encapsulated shared secret using Kyber algorithms
-*
-* @param cipherText - The encapsulated key
-* @param secretKey - The private Kyber key
-* @returns The resulting decapsulated shared secret.
-*/
-function decapsulateKyber(cipherText, secretKey) {
-	try {
-		return ml_kem768.decapsulate(cipherText, secretKey);
-	} catch (error) {
-		throw new Error("Failed to decapsulate", { cause: error });
-	}
-}
-
-//#endregion
-export { encapsulateKyber as n, generateKyberKeys as r, decapsulateKyber as t };
-//# sourceMappingURL=kyber768-SXnIo-Nw.mjs.map

package/dist/kyber768-SXnIo-Nw.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"kyber768-SXnIo-Nw.mjs","names":[],"sources":["../src/post-quantum-crypto/kyber768.ts"],"sourcesContent":["import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';\n\n/**\n * Generates public and secret Kyber keys\n *\n * @param seed - The optional seed\n * @returns The generated Kyber key pair.\n */\nexport function generateKyberKeys(seed?: Uint8Array): {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n} {\n  try {\n    return ml_kem768.keygen(seed);\n  } catch (error) {\n    throw new Error('Failed to generate Kyber keys', { cause: error });\n  }\n}\n\n/**\n * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms\n *\n * @param publicKey - The public Kyber key\n * @returns The resulting encapsulation and the generated shared secret.\n */\nexport function encapsulateKyber(publicKey: Uint8Array): {\n  cipherText: Uint8Array;\n  sharedSecret: Uint8Array;\n} {\n  try {\n    return ml_kem768.encapsulate(publicKey);\n  } catch (error) {\n    throw new Error('Failed to encapsulate', { cause: error });\n  }\n}\n\n/**\n * Decapsulates the encapsulated shared secret using Kyber algorithms\n *\n * @param cipherText - The encapsulated key\n * @param secretKey - The private Kyber key\n * @returns The resulting decapsulated shared secret.\n */\nexport function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  try {\n    return ml_kem768.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;AAQA,SAAgB,kBAAkB,MAGhC;AACA,KAAI;AACF,SAAO,UAAU,OAAO,KAAK;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgB,iBAAiB,WAG/B;AACA,KAAI;AACF,SAAO,UAAU,YAAY,UAAU;UAChC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgB,iBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAO,UAAU,YAAY,YAAY,UAAU;UAC5C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}

package/dist/kyber768-WUVc2fIR.js

@@ -1,65 +0,0 @@
-const require_chunk = require('./chunk-EbLFQX5m.js');
-let _noble_post_quantum_ml_kem_js = require("@noble/post-quantum/ml-kem.js");
-
-//#region src/post-quantum-crypto/kyber768.ts
-/**
-* Generates public and secret Kyber keys
-*
-* @param seed - The optional seed
-* @returns The generated Kyber key pair.
-*/
-function generateKyberKeys(seed) {
-	try {
-		return _noble_post_quantum_ml_kem_js.ml_kem768.keygen(seed);
-	} catch (error) {
-		throw new Error("Failed to generate Kyber keys", { cause: error });
-	}
-}
-/**
-* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
-*
-* @param publicKey - The public Kyber key
-* @returns The resulting encapsulation and the generated shared secret.
-*/
-function encapsulateKyber(publicKey) {
-	try {
-		return _noble_post_quantum_ml_kem_js.ml_kem768.encapsulate(publicKey);
-	} catch (error) {
-		throw new Error("Failed to encapsulate", { cause: error });
-	}
-}
-/**
-* Decapsulates the encapsulated shared secret using Kyber algorithms
-*
-* @param cipherText - The encapsulated key
-* @param secretKey - The private Kyber key
-* @returns The resulting decapsulated shared secret.
-*/
-function decapsulateKyber(cipherText, secretKey) {
-	try {
-		return _noble_post_quantum_ml_kem_js.ml_kem768.decapsulate(cipherText, secretKey);
-	} catch (error) {
-		throw new Error("Failed to decapsulate", { cause: error });
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'decapsulateKyber', {
-  enumerable: true,
-  get: function () {
-    return decapsulateKyber;
-  }
-});
-Object.defineProperty(exports, 'encapsulateKyber', {
-  enumerable: true,
-  get: function () {
-    return encapsulateKyber;
-  }
-});
-Object.defineProperty(exports, 'generateKyberKeys', {
-  enumerable: true,
-  get: function () {
-    return generateKyberKeys;
-  }
-});
-//# sourceMappingURL=kyber768-WUVc2fIR.js.map

package/dist/kyber768-WUVc2fIR.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"kyber768-WUVc2fIR.js","names":["ml_kem768"],"sources":["../src/post-quantum-crypto/kyber768.ts"],"sourcesContent":["import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';\n\n/**\n * Generates public and secret Kyber keys\n *\n * @param seed - The optional seed\n * @returns The generated Kyber key pair.\n */\nexport function generateKyberKeys(seed?: Uint8Array): {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n} {\n  try {\n    return ml_kem768.keygen(seed);\n  } catch (error) {\n    throw new Error('Failed to generate Kyber keys', { cause: error });\n  }\n}\n\n/**\n * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms\n *\n * @param publicKey - The public Kyber key\n * @returns The resulting encapsulation and the generated shared secret.\n */\nexport function encapsulateKyber(publicKey: Uint8Array): {\n  cipherText: Uint8Array;\n  sharedSecret: Uint8Array;\n} {\n  try {\n    return ml_kem768.encapsulate(publicKey);\n  } catch (error) {\n    throw new Error('Failed to encapsulate', { cause: error });\n  }\n}\n\n/**\n * Decapsulates the encapsulated shared secret using Kyber algorithms\n *\n * @param cipherText - The encapsulated key\n * @param secretKey - The private Kyber key\n * @returns The resulting decapsulated shared secret.\n */\nexport function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  try {\n    return ml_kem768.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AAQA,SAAgB,kBAAkB,MAGhC;AACA,KAAI;AACF,SAAOA,wCAAU,OAAO,KAAK;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgB,iBAAiB,WAG/B;AACA,KAAI;AACF,SAAOA,wCAAU,YAAY,UAAU;UAChC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgB,iBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAOA,wCAAU,YAAY,YAAY,UAAU;UAC5C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}

package/dist/mac-BMb1F0dN.js

@@ -1,170 +0,0 @@
-const require_chunk = require('./chunk-EbLFQX5m.js');
-const require_constants = require('./constants.js');
-let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
-let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
-
-//#region src/hash/blake3.ts
-/**
-* Hashes the given array of data
-*
-* @param data - The data to hash
-* @returns The resulting hash array
-*/
-function hashDataArray(data) {
-	try {
-		const hasher = _noble_hashes_blake3_js.blake3.create();
-		for (const d of data) hasher.update(d);
-		return hasher.digest();
-	} catch (error) {
-		throw new Error("Failed to compute hash", { cause: error });
-	}
-}
-/**
-* Hashes the given array of data
-*
-* @param data - The data to hash
-* @returns The resulting hash hex string
-*/
-function hashDataArrayHex(data) {
-	return (0, _noble_hashes_utils_js.bytesToHex)(hashDataArray(data));
-}
-function hashDataArrayWithKeyHex(hashKey, data) {
-	try {
-		return (0, _noble_hashes_utils_js.bytesToHex)(hashDataArrayWithKey(hashKey, data));
-	} catch (error) {
-		throw new Error("Failed to compute hash hex", { cause: error });
-	}
-}
-function hashDataArrayWithKey(hashKey, data) {
-	try {
-		const hasher = _noble_hashes_blake3_js.blake3.create({ key: hashKey });
-		for (const d of data) hasher.update(d);
-		return hasher.digest();
-	} catch (error) {
-		throw new Error("Failed to compute hash", { cause: error });
-	}
-}
-/**
-* Hashes the given array of data using blake3 algorithm
-*
-* @param bytes - The desired output byte-length
-* @param data - The data to hash
-* @returns The resulting hash value
-*/
-function getBytesFromDataArray(bytes, data) {
-	try {
-		const hasher = _noble_hashes_blake3_js.blake3.create({ dkLen: bytes });
-		for (const chunk of data) hasher.update(chunk);
-		return hasher.digest();
-	} catch (error) {
-		throw new Error("Failed to get bytes from data", { cause: error });
-	}
-}
-/**
-* Hashes the given array of data using blake3 algorithm
-*
-* @param bytes - The desired output byte-length
-* @param data - The data to hash
-* @returns The resulting hash value
-*/
-function getBytesFromDataArrayHex(bytes, data) {
-	try {
-		return (0, _noble_hashes_utils_js.bytesToHex)(getBytesFromDataArray(bytes, data));
-	} catch (error) {
-		throw new Error("Failed to get bytes from data", { cause: error });
-	}
-}
-/**
-* Hashes the given string using blake3 algorithm
-*
-* @param bytes - The desired output byte-length
-* @param data - The data to hash
-* @returns The resulting hash value
-*/
-function getBytesFromData(bytes, data) {
-	return (0, _noble_hashes_blake3_js.blake3)(data, { dkLen: bytes });
-}
-/**
-* Hashes the given data using blake3 algorithm
-*
-* @param bytes - The desired output byte-length
-* @param data - The data to hash
-* @returns The resulting hash value
-*/
-function getBytesFromDataHex(bytes, data) {
-	return (0, _noble_hashes_utils_js.bytesToHex)(getBytesFromData(bytes, data));
-}
-
-//#endregion
-//#region src/hash/mac.ts
-/**
-* Computes mac for the given key material and data
-*
-* @param keyMaterial - The key material
-* @param data - The data to hash
-* @returns The resulting hash hex string
-*/
-function computeMac(keyMaterial, data) {
-	try {
-		return (0, _noble_hashes_utils_js.bytesToHex)(hashDataArrayWithKey(getBytesFromData(require_constants.AES_KEY_BIT_LENGTH / 8, keyMaterial), data));
-	} catch (error) {
-		throw new Error("Failed to compute mac", { cause: error });
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'computeMac', {
-  enumerable: true,
-  get: function () {
-    return computeMac;
-  }
-});
-Object.defineProperty(exports, 'getBytesFromData', {
-  enumerable: true,
-  get: function () {
-    return getBytesFromData;
-  }
-});
-Object.defineProperty(exports, 'getBytesFromDataArray', {
-  enumerable: true,
-  get: function () {
-    return getBytesFromDataArray;
-  }
-});
-Object.defineProperty(exports, 'getBytesFromDataArrayHex', {
-  enumerable: true,
-  get: function () {
-    return getBytesFromDataArrayHex;
-  }
-});
-Object.defineProperty(exports, 'getBytesFromDataHex', {
-  enumerable: true,
-  get: function () {
-    return getBytesFromDataHex;
-  }
-});
-Object.defineProperty(exports, 'hashDataArray', {
-  enumerable: true,
-  get: function () {
-    return hashDataArray;
-  }
-});
-Object.defineProperty(exports, 'hashDataArrayHex', {
-  enumerable: true,
-  get: function () {
-    return hashDataArrayHex;
-  }
-});
-Object.defineProperty(exports, 'hashDataArrayWithKey', {
-  enumerable: true,
-  get: function () {
-    return hashDataArrayWithKey;
-  }
-});
-Object.defineProperty(exports, 'hashDataArrayWithKeyHex', {
-  enumerable: true,
-  get: function () {
-    return hashDataArrayWithKeyHex;
-  }
-});
-//# sourceMappingURL=mac-BMb1F0dN.js.map

package/dist/mac-BMb1F0dN.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"mac-BMb1F0dN.js","names":["blake3","AES_KEY_BIT_LENGTH"],"sources":["../src/hash/blake3.ts","../src/hash/mac.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash array\n */\nexport function hashDataArray(data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create();\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function hashDataArrayHex(data: Uint8Array[]): string {\n  return bytesToHex(hashDataArray(data));\n}\n\nexport function hashDataArrayWithKeyHex(hashKey: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const hash = hashDataArrayWithKey(hashKey, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute hash hex', { cause: error });\n  }\n}\n\nexport function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ key: hashKey });\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArray(bytes: number, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ dkLen: bytes });\n    for (const chunk of data) {\n      hasher.update(chunk);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArrayHex(bytes: number, data: Uint8Array[]): string {\n  try {\n    const hash = getBytesFromDataArray(bytes, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given string using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromData(bytes: number, data: Uint8Array): Uint8Array {\n  return blake3(data, { dkLen: bytes });\n}\n\n/**\n * Hashes the given data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataHex(bytes: number, data: Uint8Array): string {\n  return bytesToHex(getBytesFromData(bytes, data));\n}\n","import { bytesToHex } from '@noble/hashes/utils.js';\nimport { AES_KEY_BIT_LENGTH } from '../constants';\nimport { getBytesFromData, hashDataArrayWithKey } from './blake3';\n\n/**\n * Computes mac for the given key material and data\n *\n * @param keyMaterial - The key material\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const key = getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial);\n    const hash = hashDataArrayWithKey(key, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute mac', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;AASA,SAAgB,cAAc,MAAgC;AAC5D,KAAI;EACF,MAAM,SAASA,+BAAO,QAAQ;AAC9B,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU/D,SAAgB,iBAAiB,MAA4B;AAC3D,+CAAkB,cAAc,KAAK,CAAC;;AAGxC,SAAgB,wBAAwB,SAAqB,MAA4B;AACvF,KAAI;AAEF,gDADa,qBAAqB,SAAS,KAAK,CACzB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,8BAA8B,EAAE,OAAO,OAAO,CAAC;;;AAInE,SAAgB,qBAAqB,SAAqB,MAAgC;AACxF,KAAI;EACF,MAAM,SAASA,+BAAO,OAAO,EAAE,KAAK,SAAS,CAAC;AAC9C,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,sBAAsB,OAAe,MAAgC;AACnF,KAAI;EACF,MAAM,SAASA,+BAAO,OAAO,EAAE,OAAO,OAAO,CAAC;AAC9C,OAAK,MAAM,SAAS,KAClB,QAAO,OAAO,MAAM;AAEtB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,yBAAyB,OAAe,MAA4B;AAClF,KAAI;AAEF,gDADa,sBAAsB,OAAO,KAAK,CACxB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,iBAAiB,OAAe,MAA8B;AAC5E,4CAAc,MAAM,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUvC,SAAgB,oBAAoB,OAAe,MAA0B;AAC3E,+CAAkB,iBAAiB,OAAO,KAAK,CAAC;;;;;;;;;;;;AC/FlD,SAAgB,WAAW,aAAyB,MAA4B;AAC9E,KAAI;AAGF,gDADa,qBADD,iBAAiBC,uCAAqB,GAAG,YAAY,EAC1B,KAAK,CACrB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}

package/dist/mac-ZpRlx8Fs.mjs

@@ -1,116 +0,0 @@
-import { AES_KEY_BIT_LENGTH } from "./constants.mjs";
-import { blake3 } from "@noble/hashes/blake3.js";
-import { bytesToHex } from "@noble/hashes/utils.js";
-
-//#region src/hash/blake3.ts
-/**
-* Hashes the given array of data
-*
-* @param data - The data to hash
-* @returns The resulting hash array
-*/
-function hashDataArray(data) {
-	try {
-		const hasher = blake3.create();
-		for (const d of data) hasher.update(d);
-		return hasher.digest();
-	} catch (error) {
-		throw new Error("Failed to compute hash", { cause: error });
-	}
-}
-/**
-* Hashes the given array of data
-*
-* @param data - The data to hash
-* @returns The resulting hash hex string
-*/
-function hashDataArrayHex(data) {
-	return bytesToHex(hashDataArray(data));
-}
-function hashDataArrayWithKeyHex(hashKey, data) {
-	try {
-		return bytesToHex(hashDataArrayWithKey(hashKey, data));
-	} catch (error) {
-		throw new Error("Failed to compute hash hex", { cause: error });
-	}
-}
-function hashDataArrayWithKey(hashKey, data) {
-	try {
-		const hasher = blake3.create({ key: hashKey });
-		for (const d of data) hasher.update(d);
-		return hasher.digest();
-	} catch (error) {
-		throw new Error("Failed to compute hash", { cause: error });
-	}
-}
-/**
-* Hashes the given array of data using blake3 algorithm
-*
-* @param bytes - The desired output byte-length
-* @param data - The data to hash
-* @returns The resulting hash value
-*/
-function getBytesFromDataArray(bytes, data) {
-	try {
-		const hasher = blake3.create({ dkLen: bytes });
-		for (const chunk of data) hasher.update(chunk);
-		return hasher.digest();
-	} catch (error) {
-		throw new Error("Failed to get bytes from data", { cause: error });
-	}
-}
-/**
-* Hashes the given array of data using blake3 algorithm
-*
-* @param bytes - The desired output byte-length
-* @param data - The data to hash
-* @returns The resulting hash value
-*/
-function getBytesFromDataArrayHex(bytes, data) {
-	try {
-		return bytesToHex(getBytesFromDataArray(bytes, data));
-	} catch (error) {
-		throw new Error("Failed to get bytes from data", { cause: error });
-	}
-}
-/**
-* Hashes the given string using blake3 algorithm
-*
-* @param bytes - The desired output byte-length
-* @param data - The data to hash
-* @returns The resulting hash value
-*/
-function getBytesFromData(bytes, data) {
-	return blake3(data, { dkLen: bytes });
-}
-/**
-* Hashes the given data using blake3 algorithm
-*
-* @param bytes - The desired output byte-length
-* @param data - The data to hash
-* @returns The resulting hash value
-*/
-function getBytesFromDataHex(bytes, data) {
-	return bytesToHex(getBytesFromData(bytes, data));
-}
-
-//#endregion
-//#region src/hash/mac.ts
-/**
-* Computes mac for the given key material and data
-*
-* @param keyMaterial - The key material
-* @param data - The data to hash
-* @returns The resulting hash hex string
-*/
-function computeMac(keyMaterial, data) {
-	try {
-		return bytesToHex(hashDataArrayWithKey(getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial), data));
-	} catch (error) {
-		throw new Error("Failed to compute mac", { cause: error });
-	}
-}
-
-//#endregion
-export { getBytesFromDataHex as a, hashDataArrayWithKey as c, getBytesFromDataArrayHex as i, hashDataArrayWithKeyHex as l, getBytesFromData as n, hashDataArray as o, getBytesFromDataArray as r, hashDataArrayHex as s, computeMac as t };
-//# sourceMappingURL=mac-ZpRlx8Fs.mjs.map

package/dist/mac-ZpRlx8Fs.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"mac-ZpRlx8Fs.mjs","names":[],"sources":["../src/hash/blake3.ts","../src/hash/mac.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash array\n */\nexport function hashDataArray(data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create();\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function hashDataArrayHex(data: Uint8Array[]): string {\n  return bytesToHex(hashDataArray(data));\n}\n\nexport function hashDataArrayWithKeyHex(hashKey: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const hash = hashDataArrayWithKey(hashKey, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute hash hex', { cause: error });\n  }\n}\n\nexport function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ key: hashKey });\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArray(bytes: number, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ dkLen: bytes });\n    for (const chunk of data) {\n      hasher.update(chunk);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArrayHex(bytes: number, data: Uint8Array[]): string {\n  try {\n    const hash = getBytesFromDataArray(bytes, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given string using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromData(bytes: number, data: Uint8Array): Uint8Array {\n  return blake3(data, { dkLen: bytes });\n}\n\n/**\n * Hashes the given data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataHex(bytes: number, data: Uint8Array): string {\n  return bytesToHex(getBytesFromData(bytes, data));\n}\n","import { bytesToHex } from '@noble/hashes/utils.js';\nimport { AES_KEY_BIT_LENGTH } from '../constants';\nimport { getBytesFromData, hashDataArrayWithKey } from './blake3';\n\n/**\n * Computes mac for the given key material and data\n *\n * @param keyMaterial - The key material\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const key = getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial);\n    const hash = hashDataArrayWithKey(key, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute mac', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;AASA,SAAgB,cAAc,MAAgC;AAC5D,KAAI;EACF,MAAM,SAAS,OAAO,QAAQ;AAC9B,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU/D,SAAgB,iBAAiB,MAA4B;AAC3D,QAAO,WAAW,cAAc,KAAK,CAAC;;AAGxC,SAAgB,wBAAwB,SAAqB,MAA4B;AACvF,KAAI;AAEF,SAAO,WADM,qBAAqB,SAAS,KAAK,CACzB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,8BAA8B,EAAE,OAAO,OAAO,CAAC;;;AAInE,SAAgB,qBAAqB,SAAqB,MAAgC;AACxF,KAAI;EACF,MAAM,SAAS,OAAO,OAAO,EAAE,KAAK,SAAS,CAAC;AAC9C,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,sBAAsB,OAAe,MAAgC;AACnF,KAAI;EACF,MAAM,SAAS,OAAO,OAAO,EAAE,OAAO,OAAO,CAAC;AAC9C,OAAK,MAAM,SAAS,KAClB,QAAO,OAAO,MAAM;AAEtB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,yBAAyB,OAAe,MAA4B;AAClF,KAAI;AAEF,SAAO,WADM,sBAAsB,OAAO,KAAK,CACxB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,iBAAiB,OAAe,MAA8B;AAC5E,QAAO,OAAO,MAAM,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUvC,SAAgB,oBAAoB,OAAe,MAA0B;AAC3E,QAAO,WAAW,iBAAiB,OAAO,KAAK,CAAC;;;;;;;;;;;;AC/FlD,SAAgB,WAAW,aAAyB,MAA4B;AAC9E,KAAI;AAGF,SAAO,WADM,qBADD,iBAAiB,qBAAqB,GAAG,YAAY,EAC1B,KAAK,CACrB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}