internxt-crypto 0.0.9-alpha → 0.0.11

package/dist/keystore-service.js

@@ -0,0 +1,122 @@
+const require_chunk = require('./chunk-Dt-PWiN7.js');
+const require_utils = require('./utils-CNs3cyDj.js');
+let axios = require("axios");
+axios = require_chunk.__toESM(axios);
+
+//#region src/keystore-service/api.ts
+var KeyServiceAPI = class {
+	constructor(baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+	/**
+	* Converts the specific client error into a proprietary error for our apps
+	* @param error
+	* @private
+	*/
+	normalizeError(error) {
+		let errorMessage;
+		if (error.response?.status === 401) errorMessage = "Unauthorized: Invalid or expired token";
+		else if (error.response?.status === 403) errorMessage = "Forbidden: Insufficient permissions";
+		else if (error.response?.status === 404) errorMessage = "Keystore not found for the specified user";
+		else errorMessage = "AxiosError:" + (error.message ?? "Unknown error");
+		throw new Error(errorMessage);
+	}
+	/**
+	* Sends a user's encrypted keystore to the server
+	* @param keystore - The encrypted keystore
+	* @param url - The user specific part of the url
+	* @returns Server response
+	*/
+	async uploadKeystoreToServer(encryptedKeystore) {
+		try {
+			const url = `${this.baseUrl}/uploadKeystore`;
+			return await axios.default.post(url, { encryptedKeystore }, {
+				withCredentials: true,
+				headers: { "Content-Type": "application/json" }
+			});
+		} catch (error) {
+			if (axios.default.isAxiosError(error)) this.normalizeError(error);
+			throw new Error("Failed to send keystore", { cause: error });
+		}
+	}
+	/**
+	* Requests a user's encrypted keystore from the server
+	* @param url - The user-specific part of the url
+	* @returns The user's encrypted keystore as base64 string
+	*/
+	async getKeystoreFromServer(userID, keystoreType) {
+		try {
+			const url = `${this.baseUrl}/downloadKeystore`;
+			return (await axios.default.get(url, {
+				params: {
+					userID,
+					keystoreType
+				},
+				withCredentials: true,
+				headers: { "Content-Type": "application/json" }
+			})).data;
+		} catch (error) {
+			if (axios.default.isAxiosError(error)) this.normalizeError(error);
+			throw new Error("Failed to retrive keystore", { cause: error });
+		}
+	}
+	/**
+	* Obtains recipients public keys from the server
+	*
+	* @param emails - The recipients' emails
+	* @returns The list of recipients' public keys
+	*/
+	async getRecipientsPublicKeysFromServer(emails) {
+		try {
+			const url = `${this.baseUrl}/getPublicKeys`;
+			return (await axios.default.get(url, {
+				params: { emails },
+				withCredentials: true,
+				headers: { "Content-Type": "application/json" }
+			})).data;
+		} catch (error) {
+			if (axios.default.isAxiosError(error)) this.normalizeError(error);
+			throw new Error("Failed to retrieve public keys", { cause: error });
+		}
+	}
+	/**
+	* Obtains the recipient public keys from the server
+	*
+	* @param email - The recipients' emails
+	* @returns The list of recipients' public keys
+	*/
+	async getRecipientsPublicKeys(emails) {
+		try {
+			const publicKeysBase64 = await this.getRecipientsPublicKeysFromServer(emails);
+			const result = [];
+			for (const keyBase64 of publicKeysBase64) {
+				const publicKeys = await require_utils.base64ToPublicKey(keyBase64);
+				result.push(publicKeys);
+			}
+			return result;
+		} catch (error) {
+			throw new Error("Failed to get recipients public keys", { cause: error });
+		}
+	}
+};
+function getKeyServiceAPI(baseUrl) {
+	return new KeyServiceAPI(baseUrl);
+}
+
+//#endregion
+//#region src/keystore-service/index.ts
+var keystore_service_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	KeyServiceAPI: () => KeyServiceAPI,
+	getKeyServiceAPI: () => getKeyServiceAPI
+});
+
+//#endregion
+exports.KeyServiceAPI = KeyServiceAPI;
+exports.getKeyServiceAPI = getKeyServiceAPI;
+Object.defineProperty(exports, 'keystore_service_exports', {
+  enumerable: true,
+  get: function () {
+    return keystore_service_exports;
+  }
+});
+//# sourceMappingURL=keystore-service.js.map

package/dist/keystore-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore-service.js","names":["base64ToPublicKey"],"sources":["../src/keystore-service/api.ts","../src/keystore-service/index.ts"],"sourcesContent":["import axios, { AxiosResponse, AxiosError } from 'axios';\nimport { KeystoreType, EncryptedKeystore, PublicKeys, PublicKeysBase64 } from '../types';\nimport { base64ToPublicKey } from '../utils';\n\nexport class KeyServiceAPI {\n  private readonly baseUrl: string;\n\n  constructor(baseUrl: string) {\n    this.baseUrl = baseUrl;\n  }\n\n  /**\n   * Converts the specific client error into a proprietary error for our apps\n   * @param error\n   * @private\n   */\n  private normalizeError(error: AxiosError) {\n    let errorMessage: string;\n    if (error.response?.status === 401) {\n      errorMessage = 'Unauthorized: Invalid or expired token';\n    } else if (error.response?.status === 403) {\n      errorMessage = 'Forbidden: Insufficient permissions';\n    } else if (error.response?.status === 404) {\n      errorMessage = 'Keystore not found for the specified user';\n    } else {\n      errorMessage = 'AxiosError:' + (error.message ?? 'Unknown error');\n    }\n\n    throw new Error(errorMessage);\n  }\n\n  /**\n   * Sends a user's encrypted keystore to the server\n   * @param keystore - The encrypted keystore\n   * @param url - The user specific part of the url\n   * @returns Server response\n   */\n  async uploadKeystoreToServer(encryptedKeystore: EncryptedKeystore): Promise<AxiosResponse> {\n    try {\n      const url = `${this.baseUrl}/uploadKeystore`;\n      const response = await axios.post(\n        url,\n        { encryptedKeystore },\n        {\n          withCredentials: true,\n          headers: {\n            'Content-Type': 'application/json',\n          },\n        },\n      );\n      return response;\n    } catch (error) {\n      if (axios.isAxiosError(error)) {\n        this.normalizeError(error);\n      }\n      throw new Error('Failed to send keystore', { cause: error });\n    }\n  }\n\n  /**\n   * Requests a user's encrypted keystore from the server\n   * @param url - The user-specific part of the url\n   * @returns The user's encrypted keystore as base64 string\n   */\n  async getKeystoreFromServer(userID: string, keystoreType: KeystoreType): Promise<EncryptedKeystore> {\n    try {\n      const url = `${this.baseUrl}/downloadKeystore`;\n      const response = await axios.get<EncryptedKeystore>(url, {\n        params: { userID, keystoreType },\n        withCredentials: true,\n        headers: {\n          'Content-Type': 'application/json',\n        },\n      });\n      return response.data;\n    } catch (error) {\n      if (axios.isAxiosError(error)) {\n        this.normalizeError(error);\n      }\n\n      throw new Error('Failed to retrive keystore', { cause: error });\n    }\n  }\n\n  /**\n   * Obtains recipients public keys from the server\n   *\n   * @param emails - The recipients' emails\n   * @returns The list of recipients' public keys\n   */\n  async getRecipientsPublicKeysFromServer(emails: string[]): Promise<PublicKeysBase64[]> {\n    try {\n      const url = `${this.baseUrl}/getPublicKeys`;\n      const response = await axios.get<PublicKeysBase64[]>(url, {\n        params: {\n          emails: emails,\n        },\n        withCredentials: true,\n        headers: {\n          'Content-Type': 'application/json',\n        },\n      });\n      return response.data;\n    } catch (error) {\n      if (axios.isAxiosError(error)) {\n        this.normalizeError(error);\n      }\n      throw new Error('Failed to retrieve public keys', { cause: error });\n    }\n  }\n\n  /**\n   * Obtains the recipient public keys from the server\n   *\n   * @param email - The recipients' emails\n   * @returns The list of recipients' public keys\n   */\n  async getRecipientsPublicKeys(emails: string[]): Promise<PublicKeys[]> {\n    try {\n      const publicKeysBase64: PublicKeysBase64[] = await this.getRecipientsPublicKeysFromServer(emails);\n      const result: PublicKeys[] = [];\n      for (const keyBase64 of publicKeysBase64) {\n        const publicKeys = await base64ToPublicKey(keyBase64);\n        result.push(publicKeys);\n      }\n      return result;\n    } catch (error) {\n      throw new Error('Failed to get recipients public keys', { cause: error });\n    }\n  }\n}\n\nexport function getKeyServiceAPI(baseUrl: string): KeyServiceAPI {\n  return new KeyServiceAPI(baseUrl);\n}\n","export * from './api';\n"],"mappings":";;;;;;AAIA,IAAa,gBAAb,MAA2B;CAGzB,YAAY,SAAiB;AAC3B,OAAK,UAAU;;;;;;;CAQjB,AAAQ,eAAe,OAAmB;EACxC,IAAI;AACJ,MAAI,MAAM,UAAU,WAAW,IAC7B,gBAAe;WACN,MAAM,UAAU,WAAW,IACpC,gBAAe;WACN,MAAM,UAAU,WAAW,IACpC,gBAAe;MAEf,gBAAe,iBAAiB,MAAM,WAAW;AAGnD,QAAM,IAAI,MAAM,aAAa;;;;;;;;CAS/B,MAAM,uBAAuB,mBAA8D;AACzF,MAAI;GACF,MAAM,MAAM,GAAG,KAAK,QAAQ;AAW5B,UAViB,MAAM,cAAM,KAC3B,KACA,EAAE,mBAAmB,EACrB;IACE,iBAAiB;IACjB,SAAS,EACP,gBAAgB,oBACjB;IACF,CACF;WAEM,OAAO;AACd,OAAI,cAAM,aAAa,MAAM,CAC3B,MAAK,eAAe,MAAM;AAE5B,SAAM,IAAI,MAAM,2BAA2B,EAAE,OAAO,OAAO,CAAC;;;;;;;;CAShE,MAAM,sBAAsB,QAAgB,cAAwD;AAClG,MAAI;GACF,MAAM,MAAM,GAAG,KAAK,QAAQ;AAQ5B,WAPiB,MAAM,cAAM,IAAuB,KAAK;IACvD,QAAQ;KAAE;KAAQ;KAAc;IAChC,iBAAiB;IACjB,SAAS,EACP,gBAAgB,oBACjB;IACF,CAAC,EACc;WACT,OAAO;AACd,OAAI,cAAM,aAAa,MAAM,CAC3B,MAAK,eAAe,MAAM;AAG5B,SAAM,IAAI,MAAM,8BAA8B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;CAUnE,MAAM,kCAAkC,QAA+C;AACrF,MAAI;GACF,MAAM,MAAM,GAAG,KAAK,QAAQ;AAU5B,WATiB,MAAM,cAAM,IAAwB,KAAK;IACxD,QAAQ,EACE,QACT;IACD,iBAAiB;IACjB,SAAS,EACP,gBAAgB,oBACjB;IACF,CAAC,EACc;WACT,OAAO;AACd,OAAI,cAAM,aAAa,MAAM,CAC3B,MAAK,eAAe,MAAM;AAE5B,SAAM,IAAI,MAAM,kCAAkC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;CAUvE,MAAM,wBAAwB,QAAyC;AACrE,MAAI;GACF,MAAM,mBAAuC,MAAM,KAAK,kCAAkC,OAAO;GACjG,MAAM,SAAuB,EAAE;AAC/B,QAAK,MAAM,aAAa,kBAAkB;IACxC,MAAM,aAAa,MAAMA,gCAAkB,UAAU;AACrD,WAAO,KAAK,WAAW;;AAEzB,UAAO;WACA,OAAO;AACd,SAAM,IAAI,MAAM,wCAAwC,EAAE,OAAO,OAAO,CAAC;;;;AAK/E,SAAgB,iBAAiB,SAAgC;AAC/D,QAAO,IAAI,cAAc,QAAQ"}

package/dist/keystore-service.mjs

@@ -0,0 +1,114 @@
+import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
+import { c as base64ToPublicKey } from "./utils-DS04iUcX.mjs";
+import axios from "axios";
+
+//#region src/keystore-service/api.ts
+var KeyServiceAPI = class {
+	constructor(baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+	/**
+	* Converts the specific client error into a proprietary error for our apps
+	* @param error
+	* @private
+	*/
+	normalizeError(error) {
+		let errorMessage;
+		if (error.response?.status === 401) errorMessage = "Unauthorized: Invalid or expired token";
+		else if (error.response?.status === 403) errorMessage = "Forbidden: Insufficient permissions";
+		else if (error.response?.status === 404) errorMessage = "Keystore not found for the specified user";
+		else errorMessage = "AxiosError:" + (error.message ?? "Unknown error");
+		throw new Error(errorMessage);
+	}
+	/**
+	* Sends a user's encrypted keystore to the server
+	* @param keystore - The encrypted keystore
+	* @param url - The user specific part of the url
+	* @returns Server response
+	*/
+	async uploadKeystoreToServer(encryptedKeystore) {
+		try {
+			const url = `${this.baseUrl}/uploadKeystore`;
+			return await axios.post(url, { encryptedKeystore }, {
+				withCredentials: true,
+				headers: { "Content-Type": "application/json" }
+			});
+		} catch (error) {
+			if (axios.isAxiosError(error)) this.normalizeError(error);
+			throw new Error("Failed to send keystore", { cause: error });
+		}
+	}
+	/**
+	* Requests a user's encrypted keystore from the server
+	* @param url - The user-specific part of the url
+	* @returns The user's encrypted keystore as base64 string
+	*/
+	async getKeystoreFromServer(userID, keystoreType) {
+		try {
+			const url = `${this.baseUrl}/downloadKeystore`;
+			return (await axios.get(url, {
+				params: {
+					userID,
+					keystoreType
+				},
+				withCredentials: true,
+				headers: { "Content-Type": "application/json" }
+			})).data;
+		} catch (error) {
+			if (axios.isAxiosError(error)) this.normalizeError(error);
+			throw new Error("Failed to retrive keystore", { cause: error });
+		}
+	}
+	/**
+	* Obtains recipients public keys from the server
+	*
+	* @param emails - The recipients' emails
+	* @returns The list of recipients' public keys
+	*/
+	async getRecipientsPublicKeysFromServer(emails) {
+		try {
+			const url = `${this.baseUrl}/getPublicKeys`;
+			return (await axios.get(url, {
+				params: { emails },
+				withCredentials: true,
+				headers: { "Content-Type": "application/json" }
+			})).data;
+		} catch (error) {
+			if (axios.isAxiosError(error)) this.normalizeError(error);
+			throw new Error("Failed to retrieve public keys", { cause: error });
+		}
+	}
+	/**
+	* Obtains the recipient public keys from the server
+	*
+	* @param email - The recipients' emails
+	* @returns The list of recipients' public keys
+	*/
+	async getRecipientsPublicKeys(emails) {
+		try {
+			const publicKeysBase64 = await this.getRecipientsPublicKeysFromServer(emails);
+			const result = [];
+			for (const keyBase64 of publicKeysBase64) {
+				const publicKeys = await base64ToPublicKey(keyBase64);
+				result.push(publicKeys);
+			}
+			return result;
+		} catch (error) {
+			throw new Error("Failed to get recipients public keys", { cause: error });
+		}
+	}
+};
+function getKeyServiceAPI(baseUrl) {
+	return new KeyServiceAPI(baseUrl);
+}
+
+//#endregion
+//#region src/keystore-service/index.ts
+var keystore_service_exports = /* @__PURE__ */ __exportAll({
+	KeyServiceAPI: () => KeyServiceAPI,
+	getKeyServiceAPI: () => getKeyServiceAPI
+});
+
+//#endregion
+export { KeyServiceAPI, getKeyServiceAPI, keystore_service_exports as t };
+//# sourceMappingURL=keystore-service.mjs.map

package/dist/keystore-service.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore-service.mjs","names":[],"sources":["../src/keystore-service/api.ts","../src/keystore-service/index.ts"],"sourcesContent":["import axios, { AxiosResponse, AxiosError } from 'axios';\nimport { KeystoreType, EncryptedKeystore, PublicKeys, PublicKeysBase64 } from '../types';\nimport { base64ToPublicKey } from '../utils';\n\nexport class KeyServiceAPI {\n  private readonly baseUrl: string;\n\n  constructor(baseUrl: string) {\n    this.baseUrl = baseUrl;\n  }\n\n  /**\n   * Converts the specific client error into a proprietary error for our apps\n   * @param error\n   * @private\n   */\n  private normalizeError(error: AxiosError) {\n    let errorMessage: string;\n    if (error.response?.status === 401) {\n      errorMessage = 'Unauthorized: Invalid or expired token';\n    } else if (error.response?.status === 403) {\n      errorMessage = 'Forbidden: Insufficient permissions';\n    } else if (error.response?.status === 404) {\n      errorMessage = 'Keystore not found for the specified user';\n    } else {\n      errorMessage = 'AxiosError:' + (error.message ?? 'Unknown error');\n    }\n\n    throw new Error(errorMessage);\n  }\n\n  /**\n   * Sends a user's encrypted keystore to the server\n   * @param keystore - The encrypted keystore\n   * @param url - The user specific part of the url\n   * @returns Server response\n   */\n  async uploadKeystoreToServer(encryptedKeystore: EncryptedKeystore): Promise<AxiosResponse> {\n    try {\n      const url = `${this.baseUrl}/uploadKeystore`;\n      const response = await axios.post(\n        url,\n        { encryptedKeystore },\n        {\n          withCredentials: true,\n          headers: {\n            'Content-Type': 'application/json',\n          },\n        },\n      );\n      return response;\n    } catch (error) {\n      if (axios.isAxiosError(error)) {\n        this.normalizeError(error);\n      }\n      throw new Error('Failed to send keystore', { cause: error });\n    }\n  }\n\n  /**\n   * Requests a user's encrypted keystore from the server\n   * @param url - The user-specific part of the url\n   * @returns The user's encrypted keystore as base64 string\n   */\n  async getKeystoreFromServer(userID: string, keystoreType: KeystoreType): Promise<EncryptedKeystore> {\n    try {\n      const url = `${this.baseUrl}/downloadKeystore`;\n      const response = await axios.get<EncryptedKeystore>(url, {\n        params: { userID, keystoreType },\n        withCredentials: true,\n        headers: {\n          'Content-Type': 'application/json',\n        },\n      });\n      return response.data;\n    } catch (error) {\n      if (axios.isAxiosError(error)) {\n        this.normalizeError(error);\n      }\n\n      throw new Error('Failed to retrive keystore', { cause: error });\n    }\n  }\n\n  /**\n   * Obtains recipients public keys from the server\n   *\n   * @param emails - The recipients' emails\n   * @returns The list of recipients' public keys\n   */\n  async getRecipientsPublicKeysFromServer(emails: string[]): Promise<PublicKeysBase64[]> {\n    try {\n      const url = `${this.baseUrl}/getPublicKeys`;\n      const response = await axios.get<PublicKeysBase64[]>(url, {\n        params: {\n          emails: emails,\n        },\n        withCredentials: true,\n        headers: {\n          'Content-Type': 'application/json',\n        },\n      });\n      return response.data;\n    } catch (error) {\n      if (axios.isAxiosError(error)) {\n        this.normalizeError(error);\n      }\n      throw new Error('Failed to retrieve public keys', { cause: error });\n    }\n  }\n\n  /**\n   * Obtains the recipient public keys from the server\n   *\n   * @param email - The recipients' emails\n   * @returns The list of recipients' public keys\n   */\n  async getRecipientsPublicKeys(emails: string[]): Promise<PublicKeys[]> {\n    try {\n      const publicKeysBase64: PublicKeysBase64[] = await this.getRecipientsPublicKeysFromServer(emails);\n      const result: PublicKeys[] = [];\n      for (const keyBase64 of publicKeysBase64) {\n        const publicKeys = await base64ToPublicKey(keyBase64);\n        result.push(publicKeys);\n      }\n      return result;\n    } catch (error) {\n      throw new Error('Failed to get recipients public keys', { cause: error });\n    }\n  }\n}\n\nexport function getKeyServiceAPI(baseUrl: string): KeyServiceAPI {\n  return new KeyServiceAPI(baseUrl);\n}\n","export * from './api';\n"],"mappings":";;;;;AAIA,IAAa,gBAAb,MAA2B;CAGzB,YAAY,SAAiB;AAC3B,OAAK,UAAU;;;;;;;CAQjB,AAAQ,eAAe,OAAmB;EACxC,IAAI;AACJ,MAAI,MAAM,UAAU,WAAW,IAC7B,gBAAe;WACN,MAAM,UAAU,WAAW,IACpC,gBAAe;WACN,MAAM,UAAU,WAAW,IACpC,gBAAe;MAEf,gBAAe,iBAAiB,MAAM,WAAW;AAGnD,QAAM,IAAI,MAAM,aAAa;;;;;;;;CAS/B,MAAM,uBAAuB,mBAA8D;AACzF,MAAI;GACF,MAAM,MAAM,GAAG,KAAK,QAAQ;AAW5B,UAViB,MAAM,MAAM,KAC3B,KACA,EAAE,mBAAmB,EACrB;IACE,iBAAiB;IACjB,SAAS,EACP,gBAAgB,oBACjB;IACF,CACF;WAEM,OAAO;AACd,OAAI,MAAM,aAAa,MAAM,CAC3B,MAAK,eAAe,MAAM;AAE5B,SAAM,IAAI,MAAM,2BAA2B,EAAE,OAAO,OAAO,CAAC;;;;;;;;CAShE,MAAM,sBAAsB,QAAgB,cAAwD;AAClG,MAAI;GACF,MAAM,MAAM,GAAG,KAAK,QAAQ;AAQ5B,WAPiB,MAAM,MAAM,IAAuB,KAAK;IACvD,QAAQ;KAAE;KAAQ;KAAc;IAChC,iBAAiB;IACjB,SAAS,EACP,gBAAgB,oBACjB;IACF,CAAC,EACc;WACT,OAAO;AACd,OAAI,MAAM,aAAa,MAAM,CAC3B,MAAK,eAAe,MAAM;AAG5B,SAAM,IAAI,MAAM,8BAA8B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;CAUnE,MAAM,kCAAkC,QAA+C;AACrF,MAAI;GACF,MAAM,MAAM,GAAG,KAAK,QAAQ;AAU5B,WATiB,MAAM,MAAM,IAAwB,KAAK;IACxD,QAAQ,EACE,QACT;IACD,iBAAiB;IACjB,SAAS,EACP,gBAAgB,oBACjB;IACF,CAAC,EACc;WACT,OAAO;AACd,OAAI,MAAM,aAAa,MAAM,CAC3B,MAAK,eAAe,MAAM;AAE5B,SAAM,IAAI,MAAM,kCAAkC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;CAUvE,MAAM,wBAAwB,QAAyC;AACrE,MAAI;GACF,MAAM,mBAAuC,MAAM,KAAK,kCAAkC,OAAO;GACjG,MAAM,SAAuB,EAAE;AAC/B,QAAK,MAAM,aAAa,kBAAkB;IACxC,MAAM,aAAa,MAAM,kBAAkB,UAAU;AACrD,WAAO,KAAK,WAAW;;AAEzB,UAAO;WACA,OAAO;AACd,SAAM,IAAI,MAAM,wCAAwC,EAAE,OAAO,OAAO,CAAC;;;;AAK/E,SAAgB,iBAAiB,SAAgC;AAC/D,QAAO,IAAI,cAAc,QAAQ"}

package/dist/post-quantum-crypto-CAi-cEkV.js

@@ -0,0 +1,189 @@
+const require_chunk = require('./chunk-Dt-PWiN7.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
+//#region src/post-quantum-crypto/index.ts
+var post_quantum_crypto_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	decapsulateKyber: () => decapsulateKyber$2,
+	encapsulateKyber: () => encapsulateKyber$2,
+	generateKyberKeys: () => generateKyberKeys$2,
+	kyber1024: () => kyber1024_exports,
+	kyber512: () => kyber512_exports
+});
+
+//#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;
+  }
+});
+Object.defineProperty(exports, 'post_quantum_crypto_exports', {
+  enumerable: true,
+  get: function () {
+    return post_quantum_crypto_exports;
+  }
+});
+//# sourceMappingURL=post-quantum-crypto-CAi-cEkV.js.map

package/dist/post-quantum-crypto-CAi-cEkV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-quantum-crypto-CAi-cEkV.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","../src/post-quantum-crypto/index.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","export * from './kyber768';\nexport * as kyber512 from './kyber512';\nexport * as kyber1024 from './kyber1024';\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/post-quantum-crypto-Vv34t6gX.mjs

@@ -0,0 +1,154 @@
+import { t as __exportAll } from "./chunk-DWirmd9C.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
+//#region src/post-quantum-crypto/index.ts
+var post_quantum_crypto_exports = /* @__PURE__ */ __exportAll({
+	decapsulateKyber: () => decapsulateKyber$2,
+	encapsulateKyber: () => encapsulateKyber$2,
+	generateKyberKeys: () => generateKyberKeys$2,
+	kyber1024: () => kyber1024_exports,
+	kyber512: () => kyber512_exports
+});
+
+//#endregion
+export { encapsulateKyber$2 as a, decapsulateKyber$2 as i, kyber1024_exports as n, generateKyberKeys$2 as o, kyber512_exports as r, post_quantum_crypto_exports as t };
+//# sourceMappingURL=post-quantum-crypto-Vv34t6gX.mjs.map

package/dist/post-quantum-crypto-Vv34t6gX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-quantum-crypto-Vv34t6gX.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","../src/post-quantum-crypto/index.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","export * from './kyber768';\nexport * as kyber512 from './kyber512';\nexport * as kyber1024 from './kyber1024';\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/post-quantum-crypto.d.mts

@@ -0,0 +1,2 @@
+import { a as encapsulateKyber, i as decapsulateKyber, n as kyber1024_d_exports, o as generateKyberKeys, r as kyber512_d_exports } from "./index-MaOov-ag.mjs";
+export { decapsulateKyber, encapsulateKyber, generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };

package/dist/post-quantum-crypto.d.ts

@@ -0,0 +1,2 @@
+import { a as encapsulateKyber, i as decapsulateKyber, n as kyber1024_d_exports, o as generateKyberKeys, r as kyber512_d_exports } from "./index-CintVUbp.js";
+export { decapsulateKyber, encapsulateKyber, generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };

package/dist/post-quantum-crypto.js

@@ -0,0 +1,17 @@
+const require_post_quantum_crypto = require('./post-quantum-crypto-CAi-cEkV.js');
+
+exports.decapsulateKyber = require_post_quantum_crypto.decapsulateKyber;
+exports.encapsulateKyber = require_post_quantum_crypto.encapsulateKyber;
+exports.generateKyberKeys = require_post_quantum_crypto.generateKyberKeys;
+Object.defineProperty(exports, 'kyber1024', {
+  enumerable: true,
+  get: function () {
+    return require_post_quantum_crypto.kyber1024_exports;
+  }
+});
+Object.defineProperty(exports, 'kyber512', {
+  enumerable: true,
+  get: function () {
+    return require_post_quantum_crypto.kyber512_exports;
+  }
+});

package/dist/post-quantum-crypto.mjs

@@ -0,0 +1,3 @@
+import { a as encapsulateKyber, i as decapsulateKyber, n as kyber1024_exports, o as generateKyberKeys, r as kyber512_exports } from "./post-quantum-crypto-Vv34t6gX.mjs";
+
+export { decapsulateKyber, encapsulateKyber, generateKyberKeys, kyber1024_exports as kyber1024, kyber512_exports as kyber512 };