internxt-crypto 0.0.13 → 1.0.0

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/kyber1024-PpwE1rki.mjs

@@ -1,144 +0,0 @@
-import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
-import { ml_kem1024, ml_kem512, 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$2(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$2(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$2(cipherText, secretKey) {
-	try {
-		return ml_kem768.decapsulate(cipherText, secretKey);
-	} catch (error) {
-		throw new Error("Failed to decapsulate", { cause: error });
-	}
-}
-
-//#endregion
-//#region src/post-quantum-crypto/kyber512.ts
-var kyber512_exports = /* @__PURE__ */ __exportAll({
-	decapsulateKyber: () => decapsulateKyber$1,
-	encapsulateKyber: () => encapsulateKyber$1,
-	generateKyberKeys: () => generateKyberKeys$1
-});
-/**
-* Generates public and secret Kyber keys
-*
-* @param seed - The optional seed
-* @returns The generated Kyber key pair.
-*/
-function generateKyberKeys$1(seed) {
-	try {
-		return ml_kem512.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$1(publicKey) {
-	try {
-		return ml_kem512.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$1(cipherText, secretKey) {
-	try {
-		return ml_kem512.decapsulate(cipherText, secretKey);
-	} catch (error) {
-		throw new Error("Failed to decapsulate", { cause: error });
-	}
-}
-
-//#endregion
-//#region src/post-quantum-crypto/kyber1024.ts
-var kyber1024_exports = /* @__PURE__ */ __exportAll({
-	decapsulateKyber: () => decapsulateKyber,
-	encapsulateKyber: () => encapsulateKyber,
-	generateKyberKeys: () => generateKyberKeys
-});
-/**
-* Generates public and secret Kyber keys
-*
-* @param seed - The optional seed
-* @returns The generated Kyber key pair.
-*/
-function generateKyberKeys(seed) {
-	try {
-		return ml_kem1024.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_kem1024.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_kem1024.decapsulate(cipherText, secretKey);
-	} catch (error) {
-		throw new Error("Failed to decapsulate", { cause: error });
-	}
-}
-
-//#endregion
-export { generateKyberKeys$2 as a, encapsulateKyber$2 as i, kyber512_exports as n, decapsulateKyber$2 as r, kyber1024_exports as t };
-//# sourceMappingURL=kyber1024-PpwE1rki.mjs.map

package/dist/kyber1024-PpwE1rki.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"kyber1024-PpwE1rki.mjs","names":["generateKyberKeys","encapsulateKyber","decapsulateKyber","generateKyberKeys","encapsulateKyber","decapsulateKyber"],"sources":["../src/post-quantum-crypto/kyber768.ts","../src/post-quantum-crypto/kyber512.ts","../src/post-quantum-crypto/kyber1024.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","import { ml_kem512 } 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_kem512.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_kem512.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_kem512.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n","import { ml_kem1024 } 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_kem1024.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_kem1024.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_kem1024.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AAQA,SAAgBA,oBAAkB,MAGhC;AACA,KAAI;AACF,SAAO,UAAU,OAAO,KAAK;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgBC,mBAAiB,WAG/B;AACA,KAAI;AACF,SAAO,UAAU,YAAY,UAAU;UAChC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgBC,mBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAO,UAAU,YAAY,YAAY,UAAU;UAC5C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;;;;ACvC9D,SAAgBC,oBAAkB,MAGhC;AACA,KAAI;AACF,SAAO,UAAU,OAAO,KAAK;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgBC,mBAAiB,WAG/B;AACA,KAAI;AACF,SAAO,UAAU,YAAY,UAAU;UAChC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgBC,mBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAO,UAAU,YAAY,YAAY,UAAU;UAC5C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;;;;ACvC9D,SAAgB,kBAAkB,MAGhC;AACA,KAAI;AACF,SAAO,WAAW,OAAO,KAAK;UACvB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgB,iBAAiB,WAG/B;AACA,KAAI;AACF,SAAO,WAAW,YAAY,UAAU;UACjC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgB,iBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAO,WAAW,YAAY,YAAY,UAAU;UAC7C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}

package/dist/kyber1024-jeKS8CXf.js

@@ -1,173 +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$2(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$2(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$2(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
-//#region src/post-quantum-crypto/kyber512.ts
-var kyber512_exports = /* @__PURE__ */ require_chunk.__exportAll({
-	decapsulateKyber: () => decapsulateKyber$1,
-	encapsulateKyber: () => encapsulateKyber$1,
-	generateKyberKeys: () => generateKyberKeys$1
-});
-/**
-* Generates public and secret Kyber keys
-*
-* @param seed - The optional seed
-* @returns The generated Kyber key pair.
-*/
-function generateKyberKeys$1(seed) {
-	try {
-		return _noble_post_quantum_ml_kem_js.ml_kem512.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$1(publicKey) {
-	try {
-		return _noble_post_quantum_ml_kem_js.ml_kem512.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$1(cipherText, secretKey) {
-	try {
-		return _noble_post_quantum_ml_kem_js.ml_kem512.decapsulate(cipherText, secretKey);
-	} catch (error) {
-		throw new Error("Failed to decapsulate", { cause: error });
-	}
-}
-
-//#endregion
-//#region src/post-quantum-crypto/kyber1024.ts
-var kyber1024_exports = /* @__PURE__ */ require_chunk.__exportAll({
-	decapsulateKyber: () => decapsulateKyber,
-	encapsulateKyber: () => encapsulateKyber,
-	generateKyberKeys: () => generateKyberKeys
-});
-/**
-* 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_kem1024.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_kem1024.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_kem1024.decapsulate(cipherText, secretKey);
-	} catch (error) {
-		throw new Error("Failed to decapsulate", { cause: error });
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'decapsulateKyber', {
-  enumerable: true,
-  get: function () {
-    return decapsulateKyber$2;
-  }
-});
-Object.defineProperty(exports, 'encapsulateKyber', {
-  enumerable: true,
-  get: function () {
-    return encapsulateKyber$2;
-  }
-});
-Object.defineProperty(exports, 'generateKyberKeys', {
-  enumerable: true,
-  get: function () {
-    return generateKyberKeys$2;
-  }
-});
-Object.defineProperty(exports, 'kyber1024_exports', {
-  enumerable: true,
-  get: function () {
-    return kyber1024_exports;
-  }
-});
-Object.defineProperty(exports, 'kyber512_exports', {
-  enumerable: true,
-  get: function () {
-    return kyber512_exports;
-  }
-});
-//# sourceMappingURL=kyber1024-jeKS8CXf.js.map

package/dist/kyber1024-jeKS8CXf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"kyber1024-jeKS8CXf.js","names":["generateKyberKeys","ml_kem768","encapsulateKyber","decapsulateKyber","generateKyberKeys","ml_kem512","encapsulateKyber","decapsulateKyber","ml_kem1024"],"sources":["../src/post-quantum-crypto/kyber768.ts","../src/post-quantum-crypto/kyber512.ts","../src/post-quantum-crypto/kyber1024.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","import { ml_kem512 } 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_kem512.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_kem512.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_kem512.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n","import { ml_kem1024 } 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_kem1024.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_kem1024.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_kem1024.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AAQA,SAAgBA,oBAAkB,MAGhC;AACA,KAAI;AACF,SAAOC,wCAAU,OAAO,KAAK;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgBC,mBAAiB,WAG/B;AACA,KAAI;AACF,SAAOD,wCAAU,YAAY,UAAU;UAChC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgBE,mBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAOF,wCAAU,YAAY,YAAY,UAAU;UAC5C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;;;;ACvC9D,SAAgBG,oBAAkB,MAGhC;AACA,KAAI;AACF,SAAOC,wCAAU,OAAO,KAAK;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgBC,mBAAiB,WAG/B;AACA,KAAI;AACF,SAAOD,wCAAU,YAAY,UAAU;UAChC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgBE,mBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAOF,wCAAU,YAAY,YAAY,UAAU;UAC5C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;;;;ACvC9D,SAAgB,kBAAkB,MAGhC;AACA,KAAI;AACF,SAAOG,yCAAW,OAAO,KAAK;UACvB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgB,iBAAiB,WAG/B;AACA,KAAI;AACF,SAAOA,yCAAW,YAAY,UAAU;UACjC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgB,iBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAOA,yCAAW,YAAY,YAAY,UAAU;UAC7C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}

package/dist/kyber768-DGBB_RS7.d.ts

@@ -1,32 +0,0 @@
-//#region src/post-quantum-crypto/kyber768.d.ts
-/**
- * Generates public and secret Kyber keys
- *
- * @param seed - The optional seed
- * @returns The generated Kyber key pair.
- */
-declare function generateKyberKeys(seed?: Uint8Array): {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-};
-/**
- * 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.
- */
-declare function encapsulateKyber(publicKey: Uint8Array): {
-  cipherText: Uint8Array;
-  sharedSecret: Uint8Array;
-};
-/**
- * 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.
- */
-declare function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-//#endregion
-export { encapsulateKyber as n, generateKyberKeys as r, decapsulateKyber as t };
-//# sourceMappingURL=kyber768-DGBB_RS7.d.ts.map

package/dist/kyber768-DGBB_RS7.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kyber768-DGBB_RS7.d.ts","names":[],"sources":["../src/post-quantum-crypto/kyber768.ts"],"mappings":";;AAQA;;;;;iBAAgB,iBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,gBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;;;iBAgBA,gBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}

package/dist/kyber768-DzIcGg1i.d.mts

@@ -1,32 +0,0 @@
-//#region src/post-quantum-crypto/kyber768.d.ts
-/**
- * Generates public and secret Kyber keys
- *
- * @param seed - The optional seed
- * @returns The generated Kyber key pair.
- */
-declare function generateKyberKeys(seed?: Uint8Array): {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-};
-/**
- * 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.
- */
-declare function encapsulateKyber(publicKey: Uint8Array): {
-  cipherText: Uint8Array;
-  sharedSecret: Uint8Array;
-};
-/**
- * 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.
- */
-declare function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-//#endregion
-export { encapsulateKyber as n, generateKyberKeys as r, decapsulateKyber as t };
-//# sourceMappingURL=kyber768-DzIcGg1i.d.mts.map

package/dist/kyber768-DzIcGg1i.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"kyber768-DzIcGg1i.d.mts","names":[],"sources":["../src/post-quantum-crypto/kyber768.ts"],"mappings":";;AAQA;;;;;iBAAgB,iBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,gBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;;;iBAgBA,gBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}