internxt-crypto 0.0.11 → 0.0.13

package/dist/keystore-crypto.js

@@ -1,11 +1,6 @@
-require('./utils-CNs3cyDj.js');
-require('./hash-BoqwNkcd.js');
-require('./symmetric-crypto-D65zB396.js');
-require('./derive-key-CBf2WxJd.js');
-require('./post-quantum-crypto-CAi-cEkV.js');
-require('./email-crypto-BrT98taw.js');
-const require_keystore_crypto = require('./keystore-crypto-B4yCVo9l.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_emailEncryptionKey = require('./emailEncryptionKey-DbaDAdoW.js');
 
-exports.createEncryptionAndRecoveryKeystores = require_keystore_crypto.createEncryptionAndRecoveryKeystores;
-exports.openEncryptionKeystore = require_keystore_crypto.openEncryptionKeystore;
-exports.openRecoveryKeystore = require_keystore_crypto.openRecoveryKeystore;
+exports.createEncryptionAndRecoveryKeystores = require_emailEncryptionKey.createEncryptionAndRecoveryKeystores;
+exports.openEncryptionKeystore = require_emailEncryptionKey.openEncryptionKeystore;
+exports.openRecoveryKeystore = require_emailEncryptionKey.openRecoveryKeystore;

package/dist/keystore-crypto.mjs

@@ -1,9 +1,3 @@
-import "./utils-DS04iUcX.mjs";
-import "./hash-CXeGAwai.mjs";
-import "./symmetric-crypto-CrdS1Che.mjs";
-import "./derive-key-Be7hS-cN.mjs";
-import "./post-quantum-crypto-Vv34t6gX.mjs";
-import "./email-crypto-DJUEjTxA.mjs";
-import { i as openRecoveryKeystore, n as createEncryptionAndRecoveryKeystores, r as openEncryptionKeystore } from "./keystore-crypto-Bjgriq9h.mjs";
+import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-27mIHh18.mjs";
 
 export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };

package/dist/{post-quantum-crypto-Vv34t6gX.mjs → kyber1024-PpwE1rki.mjs}

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
+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
@@ -140,15 +140,5 @@ function decapsulateKyber(cipherText, secretKey) {
 }
 
 //#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
+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

@@ -0,0 +1 @@
+{"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/{post-quantum-crypto-CAi-cEkV.js → kyber1024-jeKS8CXf.js}

@@ -1,4 +1,4 @@
-const require_chunk = require('./chunk-Dt-PWiN7.js');
+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
@@ -139,16 +139,6 @@ function decapsulateKyber(cipherText, secretKey) {
 	}
 }
 
-//#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,
@@ -180,10 +170,4 @@ Object.defineProperty(exports, 'kyber512_exports', {
     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
+//# sourceMappingURL=kyber1024-jeKS8CXf.js.map

package/dist/kyber1024-jeKS8CXf.js.map

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,32 @@
+//#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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,32 @@
+//#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

@@ -0,0 +1 @@
+{"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"}

package/dist/{hash-BoqwNkcd.js → mac-BMb1F0dN.js}

@@ -1,5 +1,5 @@
-const require_chunk = require('./chunk-Dt-PWiN7.js');
-const require_constants = require('./constants-Ccp21E03.js');
+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");
 
@@ -112,20 +112,6 @@ function computeMac(keyMaterial, data) {
 	}
 }
 
-//#endregion
-//#region src/hash/index.ts
-var hash_exports = /* @__PURE__ */ require_chunk.__exportAll({
-	computeMac: () => computeMac,
-	getBytesFromData: () => getBytesFromData,
-	getBytesFromDataArray: () => getBytesFromDataArray,
-	getBytesFromDataArrayHex: () => getBytesFromDataArrayHex,
-	getBytesFromDataHex: () => getBytesFromDataHex,
-	hashDataArray: () => hashDataArray,
-	hashDataArrayHex: () => hashDataArrayHex,
-	hashDataArrayWithKey: () => hashDataArrayWithKey,
-	hashDataArrayWithKeyHex: () => hashDataArrayWithKeyHex
-});
-
 //#endregion
 Object.defineProperty(exports, 'computeMac', {
   enumerable: true,
@@ -181,10 +167,4 @@ Object.defineProperty(exports, 'hashDataArrayWithKeyHex', {
     return hashDataArrayWithKeyHex;
   }
 });
-Object.defineProperty(exports, 'hash_exports', {
-  enumerable: true,
-  get: function () {
-    return hash_exports;
-  }
-});
-//# sourceMappingURL=hash-BoqwNkcd.js.map
+//# sourceMappingURL=mac-BMb1F0dN.js.map

package/dist/mac-BMb1F0dN.js.map

@@ -0,0 +1 @@
+{"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/{hash-CXeGAwai.mjs → mac-ZpRlx8Fs.mjs}

@@ -1,5 +1,4 @@
-import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
-import { n as AES_KEY_BIT_LENGTH } from "./constants-kTeX-2T0.mjs";
+import { AES_KEY_BIT_LENGTH } from "./constants.mjs";
 import { blake3 } from "@noble/hashes/blake3.js";
 import { bytesToHex } from "@noble/hashes/utils.js";
 
@@ -113,19 +112,5 @@ function computeMac(keyMaterial, data) {
 }
 
 //#endregion
-//#region src/hash/index.ts
-var hash_exports = /* @__PURE__ */ __exportAll({
-	computeMac: () => computeMac,
-	getBytesFromData: () => getBytesFromData,
-	getBytesFromDataArray: () => getBytesFromDataArray,
-	getBytesFromDataArrayHex: () => getBytesFromDataArrayHex,
-	getBytesFromDataHex: () => getBytesFromDataHex,
-	hashDataArray: () => hashDataArray,
-	hashDataArrayHex: () => hashDataArrayHex,
-	hashDataArrayWithKey: () => hashDataArrayWithKey,
-	hashDataArrayWithKeyHex: () => hashDataArrayWithKeyHex
-});
-
-//#endregion
-export { getBytesFromDataArrayHex as a, hashDataArrayHex as c, getBytesFromDataArray as i, hashDataArrayWithKey as l, computeMac as n, getBytesFromDataHex as o, getBytesFromData as r, hashDataArray as s, hash_exports as t, hashDataArrayWithKeyHex as u };
-//# sourceMappingURL=hash-CXeGAwai.mjs.map
+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

@@ -0,0 +1 @@
+{"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"}

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

@@ -1,2 +1,68 @@
-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 };
+import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-DzIcGg1i.mjs";
+
+//#region src/post-quantum-crypto/kyber512.d.ts
+declare namespace kyber512_d_exports {
+  export { decapsulateKyber$2 as decapsulateKyber, encapsulateKyber$2 as encapsulateKyber, generateKyberKeys$2 as generateKyberKeys };
+}
+/**
+ * Generates public and secret Kyber keys
+ *
+ * @param seed - The optional seed
+ * @returns The generated Kyber key pair.
+ */
+declare function generateKyberKeys$2(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$2(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$2(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+declare namespace kyber1024_d_exports {
+  export { decapsulateKyber$1 as decapsulateKyber, encapsulateKyber$1 as encapsulateKyber, generateKyberKeys$1 as generateKyberKeys };
+}
+/**
+ * Generates public and secret Kyber keys
+ *
+ * @param seed - The optional seed
+ * @returns The generated Kyber key pair.
+ */
+declare function generateKyberKeys$1(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$1(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$1(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+//#endregion
+export { decapsulateKyber, encapsulateKyber, generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };
+//# sourceMappingURL=post-quantum-crypto.d.mts.map

package/dist/post-quantum-crypto.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-quantum-crypto.d.mts","names":[],"sources":["../src/post-quantum-crypto/kyber512.ts","../src/post-quantum-crypto/kyber1024.ts"],"mappings":";;;;;;;;;;;;iBAQgB,mBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,kBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;AAFhB;;iBAkBgB,kBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA;AAAA;;;;;;;;;iBCnCjE,mBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,kBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;ADFhB;;iBCkBgB,kBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}

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

@@ -1,2 +1,68 @@
-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 };
+import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-DGBB_RS7.js";
+
+//#region src/post-quantum-crypto/kyber512.d.ts
+declare namespace kyber512_d_exports {
+  export { decapsulateKyber$2 as decapsulateKyber, encapsulateKyber$2 as encapsulateKyber, generateKyberKeys$2 as generateKyberKeys };
+}
+/**
+ * Generates public and secret Kyber keys
+ *
+ * @param seed - The optional seed
+ * @returns The generated Kyber key pair.
+ */
+declare function generateKyberKeys$2(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$2(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$2(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+declare namespace kyber1024_d_exports {
+  export { decapsulateKyber$1 as decapsulateKyber, encapsulateKyber$1 as encapsulateKyber, generateKyberKeys$1 as generateKyberKeys };
+}
+/**
+ * Generates public and secret Kyber keys
+ *
+ * @param seed - The optional seed
+ * @returns The generated Kyber key pair.
+ */
+declare function generateKyberKeys$1(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$1(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$1(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+//#endregion
+export { decapsulateKyber, encapsulateKyber, generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };
+//# sourceMappingURL=post-quantum-crypto.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"post-quantum-crypto.d.ts","names":[],"sources":["../src/post-quantum-crypto/kyber512.ts","../src/post-quantum-crypto/kyber1024.ts"],"mappings":";;;;;;;;;;;;iBAQgB,mBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,kBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;AAFhB;;iBAkBgB,kBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA;AAAA;;;;;;;;;iBCnCjE,mBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,kBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;ADFhB;;iBCkBgB,kBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}

package/dist/post-quantum-crypto.js

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

package/dist/post-quantum-crypto.mjs

@@ -1,3 +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";
+import { a as generateKyberKeys, i as encapsulateKyber, n as kyber512_exports, r as decapsulateKyber, t as kyber1024_exports } from "./kyber1024-PpwE1rki.mjs";
 
 export { decapsulateKyber, encapsulateKyber, generateKyberKeys, kyber1024_exports as kyber1024, kyber512_exports as kyber512 };

package/dist/storage-service.d.mts

@@ -1,2 +1,47 @@
-import { n as sessionStorageService_d_exports, r as localStorageService_d_exports } from "./index-D5pBU_A5.mjs";
-export { localStorageService_d_exports as localStorageService, sessionStorageService_d_exports as sessionStorageService };
+declare namespace localStorageService_d_exports {
+  export { LocalStorageService, localStorageService as default };
+}
+declare function get$1(key: string): string | null;
+declare function set$1(key: string, value: string): void;
+declare function removeItem$1(key: string): void;
+declare function exists$1(key: string): boolean;
+declare function clear$1(): void;
+declare const localStorageService: {
+  set: typeof set$1;
+  get: typeof get$1;
+  removeItem: typeof removeItem$1;
+  exists: typeof exists$1;
+  clear: typeof clear$1;
+};
+interface LocalStorageService {
+  set: (key: string, value: string) => void;
+  get: (key: string) => string | null;
+  removeItem: (key: string) => void;
+  exists: (key: string) => boolean;
+  clear: () => void;
+}
+declare namespace sessionStorageService_d_exports {
+  export { SessionStorageService, sessionStorageService as default };
+}
+declare function get(key: string): string | null;
+declare function set(key: string, value: string): void;
+declare function removeItem(key: string): void;
+declare function exists(key: string): boolean;
+declare function clear(): void;
+declare const sessionStorageService: {
+  set: typeof set;
+  get: typeof get;
+  removeItem: typeof removeItem;
+  exists: typeof exists;
+  clear: typeof clear;
+};
+interface SessionStorageService {
+  set: (key: string, value: string) => void;
+  get: (key: string) => string | null;
+  removeItem: (key: string) => void;
+  exists: (key: string) => boolean;
+  clear: () => void;
+}
+//#endregion
+export { localStorageService_d_exports as localStorageService, sessionStorageService_d_exports as sessionStorageService };
+//# sourceMappingURL=storage-service.d.mts.map

package/dist/storage-service.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-service.d.mts","names":[],"sources":["../src/storage-service/localStorageService.ts","../src/storage-service/sessionStorageService.ts"],"mappings":";;;iBAAS,KAAA,CAAI,GAAA;AAAA,iBAIJ,KAAA,CAAI,GAAA,UAAa,KAAA;AAAA,iBAIjB,YAAA,CAAW,GAAA;AAAA,iBAIX,QAAA,CAAO,GAAA;AAAA,iBAIP,OAAA,CAAA;AAAA,cAIH,mBAAA;;;;;;;UAUW,mBAAA;EACf,GAAA,GAAM,GAAA,UAAa,KAAA;EACnB,GAAA,GAAM,GAAA;EACN,UAAA,GAAa,GAAA;EACb,MAAA,GAAS,GAAA;EACT,KAAA;AAAA;AAAA;;;iBCnCO,GAAA,CAAI,GAAA;AAAA,iBAIJ,GAAA,CAAI,GAAA,UAAa,KAAA;AAAA,iBAIjB,UAAA,CAAW,GAAA;AAAA,iBAIX,MAAA,CAAO,GAAA;AAAA,iBAIP,KAAA,CAAA;AAAA,cAIH,qBAAA;;;;;;;UAUW,qBAAA;EACf,GAAA,GAAM,GAAA,UAAa,KAAA;EACnB,GAAA,GAAM,GAAA;EACN,UAAA,GAAa,GAAA;EACb,MAAA,GAAS,GAAA;EACT,KAAA;AAAA"}

package/dist/storage-service.d.ts

@@ -1,2 +1,47 @@
-import { n as sessionStorageService_d_exports, r as localStorageService_d_exports } from "./index-CQqgKsbX.js";
-export { localStorageService_d_exports as localStorageService, sessionStorageService_d_exports as sessionStorageService };
+declare namespace localStorageService_d_exports {
+  export { LocalStorageService, localStorageService as default };
+}
+declare function get$1(key: string): string | null;
+declare function set$1(key: string, value: string): void;
+declare function removeItem$1(key: string): void;
+declare function exists$1(key: string): boolean;
+declare function clear$1(): void;
+declare const localStorageService: {
+  set: typeof set$1;
+  get: typeof get$1;
+  removeItem: typeof removeItem$1;
+  exists: typeof exists$1;
+  clear: typeof clear$1;
+};
+interface LocalStorageService {
+  set: (key: string, value: string) => void;
+  get: (key: string) => string | null;
+  removeItem: (key: string) => void;
+  exists: (key: string) => boolean;
+  clear: () => void;
+}
+declare namespace sessionStorageService_d_exports {
+  export { SessionStorageService, sessionStorageService as default };
+}
+declare function get(key: string): string | null;
+declare function set(key: string, value: string): void;
+declare function removeItem(key: string): void;
+declare function exists(key: string): boolean;
+declare function clear(): void;
+declare const sessionStorageService: {
+  set: typeof set;
+  get: typeof get;
+  removeItem: typeof removeItem;
+  exists: typeof exists;
+  clear: typeof clear;
+};
+interface SessionStorageService {
+  set: (key: string, value: string) => void;
+  get: (key: string) => string | null;
+  removeItem: (key: string) => void;
+  exists: (key: string) => boolean;
+  clear: () => void;
+}
+//#endregion
+export { localStorageService_d_exports as localStorageService, sessionStorageService_d_exports as sessionStorageService };
+//# sourceMappingURL=storage-service.d.ts.map

package/dist/storage-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-service.d.ts","names":[],"sources":["../src/storage-service/localStorageService.ts","../src/storage-service/sessionStorageService.ts"],"mappings":";;;iBAAS,KAAA,CAAI,GAAA;AAAA,iBAIJ,KAAA,CAAI,GAAA,UAAa,KAAA;AAAA,iBAIjB,YAAA,CAAW,GAAA;AAAA,iBAIX,QAAA,CAAO,GAAA;AAAA,iBAIP,OAAA,CAAA;AAAA,cAIH,mBAAA;;;;;;;UAUW,mBAAA;EACf,GAAA,GAAM,GAAA,UAAa,KAAA;EACnB,GAAA,GAAM,GAAA;EACN,UAAA,GAAa,GAAA;EACb,MAAA,GAAS,GAAA;EACT,KAAA;AAAA;AAAA;;;iBCnCO,GAAA,CAAI,GAAA;AAAA,iBAIJ,GAAA,CAAI,GAAA,UAAa,KAAA;AAAA,iBAIjB,UAAA,CAAW,GAAA;AAAA,iBAIX,MAAA,CAAO,GAAA;AAAA,iBAIP,KAAA,CAAA;AAAA,cAIH,qBAAA;;;;;;;UAUW,qBAAA;EACf,GAAA,GAAM,GAAA,UAAa,KAAA;EACnB,GAAA,GAAM,GAAA;EACN,UAAA,GAAa,GAAA;EACb,MAAA,GAAS,GAAA;EACT,KAAA;AAAA"}