internxt-crypto 1.3.0 → 1.4.0

package/dist/types-CrAiKyb0.d.ts

@@ -0,0 +1,61 @@
+//#region src/types.d.ts
+type EncryptedKeystore = {
+  userEmail: string;
+  type: KeystoreType;
+  publicKey: string;
+  privateKeyEncrypted: string;
+};
+type RecipientWithPublicKey = {
+  email: string;
+  publicHybridKey: Uint8Array;
+};
+type HybridKeyPair = {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
+type HybridEncryptedEmail = {
+  encryptedKey: HybridEncKey;
+  encEmail: EmailEncrypted;
+};
+type HybridEncryptedEmailAndSubject = {
+  encryptedKey: HybridEncKey;
+  encEmail: EmailAndSubjectEncrypted;
+};
+type PwdProtectedEmail = {
+  encryptedKey: PwdProtectedKey;
+  encEmail: EmailEncrypted;
+};
+type PwdProtectedEmailAndSubject = {
+  encryptedKey: PwdProtectedKey;
+  encEmail: EmailAndSubjectEncrypted;
+};
+type HybridEncKey = {
+  hybridCiphertext: string;
+  encryptedKey: string;
+  encryptedForEmail: string;
+};
+type PwdProtectedKey = {
+  encryptedKey: string;
+  salt: string;
+};
+type EmailEncrypted = {
+  encText: string;
+  encAttachments?: string[];
+};
+type EmailAndSubjectEncrypted = EmailEncrypted & {
+  encSubject: string;
+};
+type Email = {
+  text: string;
+  attachments?: string[];
+};
+type EmailAndSubject = Email & {
+  subject: string;
+};
+declare enum KeystoreType {
+  ENCRYPTION = "Encryption",
+  RECOVERY = "Recovery"
+}
+//#endregion
+export { EncryptedKeystore as a, HybridEncryptedEmailAndSubject as c, PwdProtectedEmail as d, PwdProtectedEmailAndSubject as f, EmailEncrypted as i, HybridKeyPair as l, RecipientWithPublicKey as m, EmailAndSubject as n, HybridEncKey as o, PwdProtectedKey as p, EmailAndSubjectEncrypted as r, HybridEncryptedEmail as s, Email as t, KeystoreType as u };
+//# sourceMappingURL=types-CrAiKyb0.d.ts.map

package/dist/types-CrAiKyb0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CrAiKyb0.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,SAAA;EACA,mBAAA;AAAA;AAAA,KAGU,sBAAA;EACV,KAAA;EACA,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,QAAA,EAAU,cAAA;AAAA;AAAA,KAGA,8BAAA;EACV,YAAA,EAAc,YAAA;EACd,QAAA,EAAU,wBAAA;AAAA;AAAA,KAGA,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,QAAA,EAAU,cAAA;AAAA;AAAA,KAGA,2BAAA;EACV,YAAA,EAAc,eAAA;EACd,QAAA,EAAU,wBAAA;AAAA;AAAA,KAGA,YAAA;EACV,gBAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,cAAA;EACV,OAAA;EACA,cAAA;AAAA;AAAA,KAGU,wBAAA,GAA2B,cAAA;EACrC,UAAA;AAAA;AAAA,KAGU,KAAA;EACV,IAAA;EACA,WAAA;AAAA;AAAA,KAGU,eAAA,GAAkB,KAAA;EAC5B,OAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}

package/dist/types-D6hsUfma.d.mts

@@ -0,0 +1,61 @@
+//#region src/types.d.ts
+type EncryptedKeystore = {
+  userEmail: string;
+  type: KeystoreType;
+  publicKey: string;
+  privateKeyEncrypted: string;
+};
+type RecipientWithPublicKey = {
+  email: string;
+  publicHybridKey: Uint8Array;
+};
+type HybridKeyPair = {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
+type HybridEncryptedEmail = {
+  encryptedKey: HybridEncKey;
+  encEmail: EmailEncrypted;
+};
+type HybridEncryptedEmailAndSubject = {
+  encryptedKey: HybridEncKey;
+  encEmail: EmailAndSubjectEncrypted;
+};
+type PwdProtectedEmail = {
+  encryptedKey: PwdProtectedKey;
+  encEmail: EmailEncrypted;
+};
+type PwdProtectedEmailAndSubject = {
+  encryptedKey: PwdProtectedKey;
+  encEmail: EmailAndSubjectEncrypted;
+};
+type HybridEncKey = {
+  hybridCiphertext: string;
+  encryptedKey: string;
+  encryptedForEmail: string;
+};
+type PwdProtectedKey = {
+  encryptedKey: string;
+  salt: string;
+};
+type EmailEncrypted = {
+  encText: string;
+  encAttachments?: string[];
+};
+type EmailAndSubjectEncrypted = EmailEncrypted & {
+  encSubject: string;
+};
+type Email = {
+  text: string;
+  attachments?: string[];
+};
+type EmailAndSubject = Email & {
+  subject: string;
+};
+declare enum KeystoreType {
+  ENCRYPTION = "Encryption",
+  RECOVERY = "Recovery"
+}
+//#endregion
+export { EncryptedKeystore as a, HybridEncryptedEmailAndSubject as c, PwdProtectedEmail as d, PwdProtectedEmailAndSubject as f, EmailEncrypted as i, HybridKeyPair as l, RecipientWithPublicKey as m, EmailAndSubject as n, HybridEncKey as o, PwdProtectedKey as p, EmailAndSubjectEncrypted as r, HybridEncryptedEmail as s, Email as t, KeystoreType as u };
+//# sourceMappingURL=types-D6hsUfma.d.mts.map

package/dist/types-D6hsUfma.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-D6hsUfma.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,SAAA;EACA,mBAAA;AAAA;AAAA,KAGU,sBAAA;EACV,KAAA;EACA,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,QAAA,EAAU,cAAA;AAAA;AAAA,KAGA,8BAAA;EACV,YAAA,EAAc,YAAA;EACd,QAAA,EAAU,wBAAA;AAAA;AAAA,KAGA,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,QAAA,EAAU,cAAA;AAAA;AAAA,KAGA,2BAAA;EACV,YAAA,EAAc,eAAA;EACd,QAAA,EAAU,wBAAA;AAAA;AAAA,KAGA,YAAA;EACV,gBAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,cAAA;EACV,OAAA;EACA,cAAA;AAAA;AAAA,KAGU,wBAAA,GAA2B,cAAA;EACrC,UAAA;AAAA;AAAA,KAGU,KAAA;EACV,IAAA;EACA,WAAA;AAAA;AAAA,KAGU,eAAA,GAAkB,KAAA;EAC5B,OAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}

package/dist/types.d.mts

@@ -1,49 +1,2 @@
-//#region src/types.d.ts
-type EncryptedKeystore = {
-  userEmail: string;
-  type: KeystoreType;
-  publicKey: string;
-  privateKeyEncrypted: string;
-};
-type RecipientWithPublicKey = {
-  email: string;
-  publicHybridKey: Uint8Array;
-};
-type HybridKeyPair = {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-};
-type HybridEncryptedEmail = {
-  encryptedKey: HybridEncKey;
-  encEmailBody: EmailBodyEncrypted;
-};
-type PwdProtectedEmail = {
-  encryptedKey: PwdProtectedKey;
-  encEmailBody: EmailBodyEncrypted;
-};
-type HybridEncKey = {
-  hybridCiphertext: string;
-  encryptedKey: string;
-  encryptedForEmail: string;
-};
-type PwdProtectedKey = {
-  encryptedKey: string;
-  salt: string;
-};
-type EmailBodyEncrypted = {
-  encText: string;
-  encSubject: string;
-  encAttachments?: string[];
-};
-type EmailBody = {
-  text: string;
-  subject: string;
-  attachments?: string[];
-};
-declare enum KeystoreType {
-  ENCRYPTION = "Encryption",
-  RECOVERY = "Recovery"
-}
-//#endregion
-export { EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey };
-//# sourceMappingURL=types.d.mts.map
+import { a as EncryptedKeystore, c as HybridEncryptedEmailAndSubject, d as PwdProtectedEmail, f as PwdProtectedEmailAndSubject, i as EmailEncrypted, l as HybridKeyPair, m as RecipientWithPublicKey, n as EmailAndSubject, o as HybridEncKey, p as PwdProtectedKey, r as EmailAndSubjectEncrypted, s as HybridEncryptedEmail, t as Email, u as KeystoreType } from "./types-D6hsUfma.mjs";
+export { Email, EmailAndSubject, EmailAndSubjectEncrypted, EmailEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridEncryptedEmailAndSubject, HybridKeyPair, KeystoreType, PwdProtectedEmail, PwdProtectedEmailAndSubject, PwdProtectedKey, RecipientWithPublicKey };

package/dist/types.d.ts

@@ -1,49 +1,2 @@
-//#region src/types.d.ts
-type EncryptedKeystore = {
-  userEmail: string;
-  type: KeystoreType;
-  publicKey: string;
-  privateKeyEncrypted: string;
-};
-type RecipientWithPublicKey = {
-  email: string;
-  publicHybridKey: Uint8Array;
-};
-type HybridKeyPair = {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-};
-type HybridEncryptedEmail = {
-  encryptedKey: HybridEncKey;
-  encEmailBody: EmailBodyEncrypted;
-};
-type PwdProtectedEmail = {
-  encryptedKey: PwdProtectedKey;
-  encEmailBody: EmailBodyEncrypted;
-};
-type HybridEncKey = {
-  hybridCiphertext: string;
-  encryptedKey: string;
-  encryptedForEmail: string;
-};
-type PwdProtectedKey = {
-  encryptedKey: string;
-  salt: string;
-};
-type EmailBodyEncrypted = {
-  encText: string;
-  encSubject: string;
-  encAttachments?: string[];
-};
-type EmailBody = {
-  text: string;
-  subject: string;
-  attachments?: string[];
-};
-declare enum KeystoreType {
-  ENCRYPTION = "Encryption",
-  RECOVERY = "Recovery"
-}
-//#endregion
-export { EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, PwdProtectedEmail, PwdProtectedKey, RecipientWithPublicKey };
-//# sourceMappingURL=types.d.ts.map
+import { a as EncryptedKeystore, c as HybridEncryptedEmailAndSubject, d as PwdProtectedEmail, f as PwdProtectedEmailAndSubject, i as EmailEncrypted, l as HybridKeyPair, m as RecipientWithPublicKey, n as EmailAndSubject, o as HybridEncKey, p as PwdProtectedKey, r as EmailAndSubjectEncrypted, s as HybridEncryptedEmail, t as Email, u as KeystoreType } from "./types-CrAiKyb0.js";
+export { Email, EmailAndSubject, EmailAndSubjectEncrypted, EmailEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridEncryptedEmailAndSubject, HybridKeyPair, KeystoreType, PwdProtectedEmail, PwdProtectedEmailAndSubject, PwdProtectedKey, RecipientWithPublicKey };

package/dist/types.js

@@ -1,12 +1,11 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/types.ts
 let KeystoreType = /* @__PURE__ */ function(KeystoreType) {
 	KeystoreType["ENCRYPTION"] = "Encryption";
 	KeystoreType["RECOVERY"] = "Recovery";
 	return KeystoreType;
 }({});
-
 //#endregion
 exports.KeystoreType = KeystoreType;
+
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  publicKey: string;\n  privateKeyEncrypted: string;\n};\n\nexport type RecipientWithPublicKey = {\n  email: string;\n  publicHybridKey: Uint8Array;\n};\n\nexport type HybridKeyPair = {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type HybridEncKey = {\n  hybridCiphertext: string;\n  encryptedKey: string;\n  encryptedForEmail: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encSubject: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  subject: string;\n  attachments?: string[];\n};\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";;;AAkDA,IAAY,sDAAL;AACL;AACA"}
+{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  publicKey: string;\n  privateKeyEncrypted: string;\n};\n\nexport type RecipientWithPublicKey = {\n  email: string;\n  publicHybridKey: Uint8Array;\n};\n\nexport type HybridKeyPair = {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  encEmail: EmailEncrypted;\n};\n\nexport type HybridEncryptedEmailAndSubject = {\n  encryptedKey: HybridEncKey;\n  encEmail: EmailAndSubjectEncrypted;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  encEmail: EmailEncrypted;\n};\n\nexport type PwdProtectedEmailAndSubject = {\n  encryptedKey: PwdProtectedKey;\n  encEmail: EmailAndSubjectEncrypted;\n};\n\nexport type HybridEncKey = {\n  hybridCiphertext: string;\n  encryptedKey: string;\n  encryptedForEmail: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailEncrypted = {\n  encText: string;\n  encAttachments?: string[];\n};\n\nexport type EmailAndSubjectEncrypted = EmailEncrypted & {\n  encSubject: string;\n};\n\nexport type Email = {\n  text: string;\n  attachments?: string[];\n};\n\nexport type EmailAndSubject = Email & {\n  subject: string;\n};\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";;AAkEA,IAAY,eAAL,yBAAA,cAAA;AACL,cAAA,gBAAA;AACA,cAAA,cAAA;;KACD"}

package/dist/types.mjs

@@ -4,7 +4,7 @@ let KeystoreType = /* @__PURE__ */ function(KeystoreType) {
 	KeystoreType["RECOVERY"] = "Recovery";
 	return KeystoreType;
 }({});
-
 //#endregion
 export { KeystoreType };
+
 //# sourceMappingURL=types.mjs.map

package/dist/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  publicKey: string;\n  privateKeyEncrypted: string;\n};\n\nexport type RecipientWithPublicKey = {\n  email: string;\n  publicHybridKey: Uint8Array;\n};\n\nexport type HybridKeyPair = {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  encEmailBody: EmailBodyEncrypted;\n};\n\nexport type HybridEncKey = {\n  hybridCiphertext: string;\n  encryptedKey: string;\n  encryptedForEmail: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encSubject: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  subject: string;\n  attachments?: string[];\n};\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";AAkDA,IAAY,sDAAL;AACL;AACA"}
+{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  publicKey: string;\n  privateKeyEncrypted: string;\n};\n\nexport type RecipientWithPublicKey = {\n  email: string;\n  publicHybridKey: Uint8Array;\n};\n\nexport type HybridKeyPair = {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  encEmail: EmailEncrypted;\n};\n\nexport type HybridEncryptedEmailAndSubject = {\n  encryptedKey: HybridEncKey;\n  encEmail: EmailAndSubjectEncrypted;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  encEmail: EmailEncrypted;\n};\n\nexport type PwdProtectedEmailAndSubject = {\n  encryptedKey: PwdProtectedKey;\n  encEmail: EmailAndSubjectEncrypted;\n};\n\nexport type HybridEncKey = {\n  hybridCiphertext: string;\n  encryptedKey: string;\n  encryptedForEmail: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailEncrypted = {\n  encText: string;\n  encAttachments?: string[];\n};\n\nexport type EmailAndSubjectEncrypted = EmailEncrypted & {\n  encSubject: string;\n};\n\nexport type Email = {\n  text: string;\n  attachments?: string[];\n};\n\nexport type EmailAndSubject = Email & {\n  subject: string;\n};\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";AAkEA,IAAY,eAAL,yBAAA,cAAA;AACL,cAAA,gBAAA;AACA,cAAA,cAAA;;KACD"}

package/dist/utils.js

@@ -1,15 +1,128 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_genID = require('./genID-cWOPmspk.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("./chunk-C13QxCFV.js");
+require("./constants.js");
+let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
+let _scure_bip39 = require("@scure/bip39");
+_scure_bip39 = require_chunk.__toESM(_scure_bip39);
+let _scure_bip39_wordlists_english_js = require("@scure/bip39/wordlists/english.js");
+let uuid = require("uuid");
+//#region src/utils/converters.ts
+/**
+* Converts a Uint8Array into a hexadecimal string.
+*
+* @param array - The Uint8Array to convert.
+* @returns The hexadecimal string representation of the array.
+*/
+function uint8ArrayToHex(array) {
+	return (0, _noble_hashes_utils_js.bytesToHex)(array);
+}
+/**
+* Converts a UTF-8 string into a Uint8Array.
+*
+* @param str - The UTF-8 string to convert.
+* @returns A Uint8Array created from the UTF-8 string.
+*/
+function UTF8ToUint8(str) {
+	return new TextEncoder().encode(str);
+}
+/**
+* Converts an Uint8Array into a UTF-8 string.
+*
+* @param array - The Uint8Array to convert.
+* @returns The UTF-8 string representation of the array.
+*/
+function uint8ToUTF8(array) {
+	return new TextDecoder().decode(array);
+}
+/**
+* Converts a hexadecimal string into a Uint8Array.
+*
+* @param hex - The hexadecimal string to convert.
+* @returns A Uint8Array created from the hex string.
+*/
+function hexToUint8Array(hex) {
+	return (0, _noble_hashes_utils_js.hexToBytes)(hex);
+}
+/**
+* Converts a Uint8Array into a base64 string.
+*
+* @param array - The Uint8Array to convert.
+* @returns The base64 string representation of the array.
+*/
+function uint8ArrayToBase64(buffer) {
+	const array = Uint16Array.from(buffer);
+	const binaryString = new TextDecoder("UTF-16").decode(array);
+	return btoa(binaryString);
+}
+/**
+* Converts a base64 string into a Uint8Array.
+*
+* @param str - The base64 string to convert.
+* @returns A Uint8Array created from the base64 string.
+*/
+function base64ToUint8Array(str) {
+	const binaryString = atob(str);
+	const len = binaryString.length;
+	const array = new Uint8Array(len);
+	for (let i = 0; i < len; i++) array[i] = binaryString.codePointAt(i);
+	return new Uint8Array(array.buffer);
+}
+//#endregion
+//#region src/utils/genMnemonic.ts
+/**
+* Generates a mnemonic
+*
+* @returns The generated mnemonic.
+*/
+function genMnemonic() {
+	return _scure_bip39.generateMnemonic(_scure_bip39_wordlists_english_js.wordlist, 256);
+}
+/**
+* Converts a mnemonic to Uint8Array
+*
+* @param mnemonic - The mnemonic to convert
+* @returns The mnemonic as Uint8Array
+*/
+function mnemonicToBytes(mnemonic) {
+	return _scure_bip39.mnemonicToEntropy(mnemonic, _scure_bip39_wordlists_english_js.wordlist);
+}
+/**
+* Converts a Uint8Array to a mnemonic
+*
+* @param bytes - The bytes to convert
+* @returns The mnemonic string
+*/
+function bytesToMnemonic(bytes) {
+	return _scure_bip39.entropyToMnemonic(bytes, _scure_bip39_wordlists_english_js.wordlist);
+}
+//#endregion
+//#region src/utils/genID.ts
+/**
+* Creates a random identifier.
+*
+* @returns The resulting auxilary string
+*/
+function generateUuid() {
+	return (0, uuid.v4)();
+}
+function uuidToBytes(uuid$1) {
+	return (0, uuid.parse)(uuid$1);
+}
+function bytesToUuid(bytes) {
+	return (0, uuid.stringify)(bytes);
+}
+//#endregion
+exports.UTF8ToUint8 = UTF8ToUint8;
+exports.base64ToUint8Array = base64ToUint8Array;
+exports.bytesToMnemonic = bytesToMnemonic;
+exports.bytesToUuid = bytesToUuid;
+exports.genMnemonic = genMnemonic;
+exports.generateUuid = generateUuid;
+exports.hexToUint8Array = hexToUint8Array;
+exports.mnemonicToBytes = mnemonicToBytes;
+exports.uint8ArrayToBase64 = uint8ArrayToBase64;
+exports.uint8ArrayToHex = uint8ArrayToHex;
+exports.uint8ToUTF8 = uint8ToUTF8;
+exports.uuidToBytes = uuidToBytes;
 
-exports.UTF8ToUint8 = require_genID.UTF8ToUint8;
-exports.base64ToUint8Array = require_genID.base64ToUint8Array;
-exports.bytesToMnemonic = require_genID.bytesToMnemonic;
-exports.bytesToUuid = require_genID.bytesToUuid;
-exports.genMnemonic = require_genID.genMnemonic;
-exports.generateUuid = require_genID.generateUuid;
-exports.hexToUint8Array = require_genID.hexToUint8Array;
-exports.mnemonicToBytes = require_genID.mnemonicToBytes;
-exports.uint8ArrayToBase64 = require_genID.uint8ArrayToBase64;
-exports.uint8ArrayToHex = require_genID.uint8ArrayToHex;
-exports.uint8ToUTF8 = require_genID.uint8ToUTF8;
-exports.uuidToBytes = require_genID.uuidToBytes;
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":["bip39","wordlist","uuid"],"sources":["../src/utils/converters.ts","../src/utils/genMnemonic.ts","../src/utils/genID.ts"],"sourcesContent":["import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\n\n/**\n * Converts a Uint8Array into a hexadecimal string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The hexadecimal string representation of the array.\n */\nexport function uint8ArrayToHex(array: Uint8Array): string {\n  return bytesToHex(array);\n}\n\n/**\n * Converts a UTF-8 string into a Uint8Array.\n *\n * @param str - The UTF-8 string to convert.\n * @returns A Uint8Array created from the UTF-8 string.\n */\nexport function UTF8ToUint8(str: string): Uint8Array {\n  return new TextEncoder().encode(str);\n}\n\n/**\n * Converts an Uint8Array into a UTF-8 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The UTF-8 string representation of the array.\n */\nexport function uint8ToUTF8(array: Uint8Array): string {\n  return new TextDecoder().decode(array);\n}\n\n/**\n * Converts a hexadecimal string into a Uint8Array.\n *\n * @param hex - The hexadecimal string to convert.\n * @returns A Uint8Array created from the hex string.\n */\nexport function hexToUint8Array(hex: string): Uint8Array {\n  return hexToBytes(hex);\n}\n\n/**\n * Converts a Uint8Array into a base64 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The base64 string representation of the array.\n */\nexport function uint8ArrayToBase64(buffer: Uint8Array): string {\n  const array = Uint16Array.from(buffer);\n  const binaryString = new TextDecoder('UTF-16').decode(array);\n  return btoa(binaryString);\n}\n\n/**\n * Converts a base64 string into a Uint8Array.\n *\n * @param str - The base64 string to convert.\n * @returns A Uint8Array created from the base64 string.\n */\nexport function base64ToUint8Array(str: string): Uint8Array {\n  const binaryString = atob(str);\n  const len = binaryString.length;\n  const array = new Uint8Array(len);\n  for (let i = 0; i < len; i++) {\n    array[i] = binaryString.codePointAt(i)!;\n  }\n  return new Uint8Array(array.buffer);\n}\n","import * as bip39 from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english.js';\nimport { AES_KEY_BYTE_LENGTH } from '../constants';\n/**\n * Generates a mnemonic\n *\n * @returns The generated mnemonic.\n */\nexport function genMnemonic(): string {\n  return bip39.generateMnemonic(wordlist, AES_KEY_BYTE_LENGTH * 8);\n}\n\n/**\n * Converts a mnemonic to Uint8Array\n *\n * @param mnemonic - The mnemonic to convert\n * @returns The mnemonic as Uint8Array\n */\nexport function mnemonicToBytes(mnemonic: string): Uint8Array {\n  return bip39.mnemonicToEntropy(mnemonic, wordlist);\n}\n\n/**\n * Converts a Uint8Array to a mnemonic\n *\n * @param bytes - The bytes to convert\n * @returns The mnemonic string\n */\nexport function bytesToMnemonic(bytes: Uint8Array): string {\n  return bip39.entropyToMnemonic(bytes, wordlist);\n}\n","import { v4 as uuidv4, parse, stringify } from 'uuid';\n/**\n * Creates a random identifier.\n *\n * @returns The resulting auxilary string\n */\nexport function generateUuid(): string {\n  return uuidv4();\n}\n\nexport function uuidToBytes(uuid: string): Uint8Array {\n  return parse(uuid);\n}\n\nexport function bytesToUuid(bytes: Uint8Array): string {\n  return stringify(bytes);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAQA,SAAgB,gBAAgB,OAA2B;AACzD,SAAA,GAAA,uBAAA,YAAkB,MAAM;;;;;;;;AAS1B,SAAgB,YAAY,KAAyB;AACnD,QAAO,IAAI,aAAa,CAAC,OAAO,IAAI;;;;;;;;AAStC,SAAgB,YAAY,OAA2B;AACrD,QAAO,IAAI,aAAa,CAAC,OAAO,MAAM;;;;;;;;AASxC,SAAgB,gBAAgB,KAAyB;AACvD,SAAA,GAAA,uBAAA,YAAkB,IAAI;;;;;;;;AASxB,SAAgB,mBAAmB,QAA4B;CAC7D,MAAM,QAAQ,YAAY,KAAK,OAAO;CACtC,MAAM,eAAe,IAAI,YAAY,SAAS,CAAC,OAAO,MAAM;AAC5D,QAAO,KAAK,aAAa;;;;;;;;AAS3B,SAAgB,mBAAmB,KAAyB;CAC1D,MAAM,eAAe,KAAK,IAAI;CAC9B,MAAM,MAAM,aAAa;CACzB,MAAM,QAAQ,IAAI,WAAW,IAAI;AACjC,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IACvB,OAAM,KAAK,aAAa,YAAY,EAAE;AAExC,QAAO,IAAI,WAAW,MAAM,OAAO;;;;;;;;;AC3DrC,SAAgB,cAAsB;AACpC,QAAOA,aAAM,iBAAiBC,kCAAAA,UAAAA,IAAkC;;;;;;;;AASlE,SAAgB,gBAAgB,UAA8B;AAC5D,QAAOD,aAAM,kBAAkB,UAAUC,kCAAAA,SAAS;;;;;;;;AASpD,SAAgB,gBAAgB,OAA2B;AACzD,QAAOD,aAAM,kBAAkB,OAAOC,kCAAAA,SAAS;;;;;;;;;ACvBjD,SAAgB,eAAuB;AACrC,SAAA,GAAA,KAAA,KAAe;;AAGjB,SAAgB,YAAY,QAA0B;AACpD,SAAA,GAAA,KAAA,OAAaC,OAAK;;AAGpB,SAAgB,YAAY,OAA2B;AACrD,SAAA,GAAA,KAAA,WAAiB,MAAM"}

package/dist/utils.mjs

@@ -1,3 +1,114 @@
-import { a as genMnemonic, c as base64ToUint8Array, d as uint8ArrayToHex, f as uint8ToUTF8, i as bytesToMnemonic, l as hexToUint8Array, n as generateUuid, o as mnemonicToBytes, r as uuidToBytes, s as UTF8ToUint8, t as bytesToUuid, u as uint8ArrayToBase64 } from "./genID-D08K7JPr.mjs";
+import "./constants.mjs";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
+import * as bip39 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { parse, stringify, v4 } from "uuid";
+//#region src/utils/converters.ts
+/**
+* Converts a Uint8Array into a hexadecimal string.
+*
+* @param array - The Uint8Array to convert.
+* @returns The hexadecimal string representation of the array.
+*/
+function uint8ArrayToHex(array) {
+	return bytesToHex(array);
+}
+/**
+* Converts a UTF-8 string into a Uint8Array.
+*
+* @param str - The UTF-8 string to convert.
+* @returns A Uint8Array created from the UTF-8 string.
+*/
+function UTF8ToUint8(str) {
+	return new TextEncoder().encode(str);
+}
+/**
+* Converts an Uint8Array into a UTF-8 string.
+*
+* @param array - The Uint8Array to convert.
+* @returns The UTF-8 string representation of the array.
+*/
+function uint8ToUTF8(array) {
+	return new TextDecoder().decode(array);
+}
+/**
+* Converts a hexadecimal string into a Uint8Array.
+*
+* @param hex - The hexadecimal string to convert.
+* @returns A Uint8Array created from the hex string.
+*/
+function hexToUint8Array(hex) {
+	return hexToBytes(hex);
+}
+/**
+* Converts a Uint8Array into a base64 string.
+*
+* @param array - The Uint8Array to convert.
+* @returns The base64 string representation of the array.
+*/
+function uint8ArrayToBase64(buffer) {
+	const array = Uint16Array.from(buffer);
+	const binaryString = new TextDecoder("UTF-16").decode(array);
+	return btoa(binaryString);
+}
+/**
+* Converts a base64 string into a Uint8Array.
+*
+* @param str - The base64 string to convert.
+* @returns A Uint8Array created from the base64 string.
+*/
+function base64ToUint8Array(str) {
+	const binaryString = atob(str);
+	const len = binaryString.length;
+	const array = new Uint8Array(len);
+	for (let i = 0; i < len; i++) array[i] = binaryString.codePointAt(i);
+	return new Uint8Array(array.buffer);
+}
+//#endregion
+//#region src/utils/genMnemonic.ts
+/**
+* Generates a mnemonic
+*
+* @returns The generated mnemonic.
+*/
+function genMnemonic() {
+	return bip39.generateMnemonic(wordlist, 256);
+}
+/**
+* Converts a mnemonic to Uint8Array
+*
+* @param mnemonic - The mnemonic to convert
+* @returns The mnemonic as Uint8Array
+*/
+function mnemonicToBytes(mnemonic) {
+	return bip39.mnemonicToEntropy(mnemonic, wordlist);
+}
+/**
+* Converts a Uint8Array to a mnemonic
+*
+* @param bytes - The bytes to convert
+* @returns The mnemonic string
+*/
+function bytesToMnemonic(bytes) {
+	return bip39.entropyToMnemonic(bytes, wordlist);
+}
+//#endregion
+//#region src/utils/genID.ts
+/**
+* Creates a random identifier.
+*
+* @returns The resulting auxilary string
+*/
+function generateUuid() {
+	return v4();
+}
+function uuidToBytes(uuid) {
+	return parse(uuid);
+}
+function bytesToUuid(bytes) {
+	return stringify(bytes);
+}
+//#endregion
+export { UTF8ToUint8, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
 
-export { UTF8ToUint8, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
+//# sourceMappingURL=utils.mjs.map

package/dist/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":["uuidv4"],"sources":["../src/utils/converters.ts","../src/utils/genMnemonic.ts","../src/utils/genID.ts"],"sourcesContent":["import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';\n\n/**\n * Converts a Uint8Array into a hexadecimal string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The hexadecimal string representation of the array.\n */\nexport function uint8ArrayToHex(array: Uint8Array): string {\n  return bytesToHex(array);\n}\n\n/**\n * Converts a UTF-8 string into a Uint8Array.\n *\n * @param str - The UTF-8 string to convert.\n * @returns A Uint8Array created from the UTF-8 string.\n */\nexport function UTF8ToUint8(str: string): Uint8Array {\n  return new TextEncoder().encode(str);\n}\n\n/**\n * Converts an Uint8Array into a UTF-8 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The UTF-8 string representation of the array.\n */\nexport function uint8ToUTF8(array: Uint8Array): string {\n  return new TextDecoder().decode(array);\n}\n\n/**\n * Converts a hexadecimal string into a Uint8Array.\n *\n * @param hex - The hexadecimal string to convert.\n * @returns A Uint8Array created from the hex string.\n */\nexport function hexToUint8Array(hex: string): Uint8Array {\n  return hexToBytes(hex);\n}\n\n/**\n * Converts a Uint8Array into a base64 string.\n *\n * @param array - The Uint8Array to convert.\n * @returns The base64 string representation of the array.\n */\nexport function uint8ArrayToBase64(buffer: Uint8Array): string {\n  const array = Uint16Array.from(buffer);\n  const binaryString = new TextDecoder('UTF-16').decode(array);\n  return btoa(binaryString);\n}\n\n/**\n * Converts a base64 string into a Uint8Array.\n *\n * @param str - The base64 string to convert.\n * @returns A Uint8Array created from the base64 string.\n */\nexport function base64ToUint8Array(str: string): Uint8Array {\n  const binaryString = atob(str);\n  const len = binaryString.length;\n  const array = new Uint8Array(len);\n  for (let i = 0; i < len; i++) {\n    array[i] = binaryString.codePointAt(i)!;\n  }\n  return new Uint8Array(array.buffer);\n}\n","import * as bip39 from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english.js';\nimport { AES_KEY_BYTE_LENGTH } from '../constants';\n/**\n * Generates a mnemonic\n *\n * @returns The generated mnemonic.\n */\nexport function genMnemonic(): string {\n  return bip39.generateMnemonic(wordlist, AES_KEY_BYTE_LENGTH * 8);\n}\n\n/**\n * Converts a mnemonic to Uint8Array\n *\n * @param mnemonic - The mnemonic to convert\n * @returns The mnemonic as Uint8Array\n */\nexport function mnemonicToBytes(mnemonic: string): Uint8Array {\n  return bip39.mnemonicToEntropy(mnemonic, wordlist);\n}\n\n/**\n * Converts a Uint8Array to a mnemonic\n *\n * @param bytes - The bytes to convert\n * @returns The mnemonic string\n */\nexport function bytesToMnemonic(bytes: Uint8Array): string {\n  return bip39.entropyToMnemonic(bytes, wordlist);\n}\n","import { v4 as uuidv4, parse, stringify } from 'uuid';\n/**\n * Creates a random identifier.\n *\n * @returns The resulting auxilary string\n */\nexport function generateUuid(): string {\n  return uuidv4();\n}\n\nexport function uuidToBytes(uuid: string): Uint8Array {\n  return parse(uuid);\n}\n\nexport function bytesToUuid(bytes: Uint8Array): string {\n  return stringify(bytes);\n}\n"],"mappings":";;;;;;;;;;;;AAQA,SAAgB,gBAAgB,OAA2B;AACzD,QAAO,WAAW,MAAM;;;;;;;;AAS1B,SAAgB,YAAY,KAAyB;AACnD,QAAO,IAAI,aAAa,CAAC,OAAO,IAAI;;;;;;;;AAStC,SAAgB,YAAY,OAA2B;AACrD,QAAO,IAAI,aAAa,CAAC,OAAO,MAAM;;;;;;;;AASxC,SAAgB,gBAAgB,KAAyB;AACvD,QAAO,WAAW,IAAI;;;;;;;;AASxB,SAAgB,mBAAmB,QAA4B;CAC7D,MAAM,QAAQ,YAAY,KAAK,OAAO;CACtC,MAAM,eAAe,IAAI,YAAY,SAAS,CAAC,OAAO,MAAM;AAC5D,QAAO,KAAK,aAAa;;;;;;;;AAS3B,SAAgB,mBAAmB,KAAyB;CAC1D,MAAM,eAAe,KAAK,IAAI;CAC9B,MAAM,MAAM,aAAa;CACzB,MAAM,QAAQ,IAAI,WAAW,IAAI;AACjC,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,IACvB,OAAM,KAAK,aAAa,YAAY,EAAE;AAExC,QAAO,IAAI,WAAW,MAAM,OAAO;;;;;;;;;AC3DrC,SAAgB,cAAsB;AACpC,QAAO,MAAM,iBAAiB,UAAA,IAAkC;;;;;;;;AASlE,SAAgB,gBAAgB,UAA8B;AAC5D,QAAO,MAAM,kBAAkB,UAAU,SAAS;;;;;;;;AASpD,SAAgB,gBAAgB,OAA2B;AACzD,QAAO,MAAM,kBAAkB,OAAO,SAAS;;;;;;;;;ACvBjD,SAAgB,eAAuB;AACrC,QAAOA,IAAQ;;AAGjB,SAAgB,YAAY,MAA0B;AACpD,QAAO,MAAM,KAAK;;AAGpB,SAAgB,YAAY,OAA2B;AACrD,QAAO,UAAU,MAAM"}

package/dist/{xwing-iRWVRtNE.js → xwing-7fEqAT7W.js}

@@ -1,6 +1,5 @@
-const require_chunk = require('./chunk-EbLFQX5m.js');
+require("./chunk-C13QxCFV.js");
 let _noble_post_quantum_hybrid_js = require("@noble/post-quantum/hybrid.js");
-
 //#region src/hybrid-crypto/xwing.ts
 function genHybridKeys(seed) {
 	return _noble_post_quantum_hybrid_js.ml_kem768_x25519.keygen(seed);
@@ -11,24 +10,24 @@ function encapsulateHybrid(publicKey) {
 function decapsulateHybrid(cipherText, secretKey) {
 	return _noble_post_quantum_hybrid_js.ml_kem768_x25519.decapsulate(cipherText, secretKey);
 }
-
 //#endregion
-Object.defineProperty(exports, 'decapsulateHybrid', {
-  enumerable: true,
-  get: function () {
-    return decapsulateHybrid;
-  }
+Object.defineProperty(exports, "decapsulateHybrid", {
+	enumerable: true,
+	get: function() {
+		return decapsulateHybrid;
+	}
 });
-Object.defineProperty(exports, 'encapsulateHybrid', {
-  enumerable: true,
-  get: function () {
-    return encapsulateHybrid;
-  }
+Object.defineProperty(exports, "encapsulateHybrid", {
+	enumerable: true,
+	get: function() {
+		return encapsulateHybrid;
+	}
 });
-Object.defineProperty(exports, 'genHybridKeys', {
-  enumerable: true,
-  get: function () {
-    return genHybridKeys;
-  }
+Object.defineProperty(exports, "genHybridKeys", {
+	enumerable: true,
+	get: function() {
+		return genHybridKeys;
+	}
 });
-//# sourceMappingURL=xwing-iRWVRtNE.js.map
+
+//# sourceMappingURL=xwing-7fEqAT7W.js.map

package/dist/{xwing-iRWVRtNE.js.map → xwing-7fEqAT7W.js.map}

@@ -1 +1 @@
-{"version":3,"file":"xwing-iRWVRtNE.js","names":["hybridCipher"],"sources":["../src/hybrid-crypto/xwing.ts"],"sourcesContent":["import { ml_kem768_x25519 as hybridCipher } from '@noble/post-quantum/hybrid.js';\nimport { HybridKeyPair } from '../types';\n\nexport function genHybridKeys(seed?: Uint8Array): HybridKeyPair {\n  return hybridCipher.keygen(seed);\n}\n\nexport function encapsulateHybrid(publicKey: Uint8Array): { cipherText: Uint8Array; sharedSecret: Uint8Array } {\n  return hybridCipher.encapsulate(publicKey);\n}\n\nexport function decapsulateHybrid(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  return hybridCipher.decapsulate(cipherText, secretKey);\n}\n"],"mappings":";;;;AAGA,SAAgB,cAAc,MAAkC;AAC9D,QAAOA,+CAAa,OAAO,KAAK;;AAGlC,SAAgB,kBAAkB,WAA6E;AAC7G,QAAOA,+CAAa,YAAY,UAAU;;AAG5C,SAAgB,kBAAkB,YAAwB,WAAmC;AAC3F,QAAOA,+CAAa,YAAY,YAAY,UAAU"}
+{"version":3,"file":"xwing-7fEqAT7W.js","names":["hybridCipher"],"sources":["../src/hybrid-crypto/xwing.ts"],"sourcesContent":["import { ml_kem768_x25519 as hybridCipher } from '@noble/post-quantum/hybrid.js';\nimport { HybridKeyPair } from '../types';\n\nexport function genHybridKeys(seed?: Uint8Array): HybridKeyPair {\n  return hybridCipher.keygen(seed);\n}\n\nexport function encapsulateHybrid(publicKey: Uint8Array): { cipherText: Uint8Array; sharedSecret: Uint8Array } {\n  return hybridCipher.encapsulate(publicKey);\n}\n\nexport function decapsulateHybrid(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  return hybridCipher.decapsulate(cipherText, secretKey);\n}\n"],"mappings":";;;AAGA,SAAgB,cAAc,MAAkC;AAC9D,QAAOA,8BAAAA,iBAAa,OAAO,KAAK;;AAGlC,SAAgB,kBAAkB,WAA6E;AAC7G,QAAOA,8BAAAA,iBAAa,YAAY,UAAU;;AAG5C,SAAgB,kBAAkB,YAAwB,WAAmC;AAC3F,QAAOA,8BAAAA,iBAAa,YAAY,YAAY,UAAU"}

package/dist/{xwing-CQmQX6hn.mjs → xwing-B34h5e3Z.mjs}

@@ -1,5 +1,4 @@
 import { ml_kem768_x25519 } from "@noble/post-quantum/hybrid.js";
-
 //#region src/hybrid-crypto/xwing.ts
 function genHybridKeys(seed) {
 	return ml_kem768_x25519.keygen(seed);
@@ -10,7 +9,7 @@ function encapsulateHybrid(publicKey) {
 function decapsulateHybrid(cipherText, secretKey) {
 	return ml_kem768_x25519.decapsulate(cipherText, secretKey);
 }
-
 //#endregion
 export { encapsulateHybrid as n, genHybridKeys as r, decapsulateHybrid as t };
-//# sourceMappingURL=xwing-CQmQX6hn.mjs.map
+
+//# sourceMappingURL=xwing-B34h5e3Z.mjs.map

package/dist/{xwing-CQmQX6hn.mjs.map → xwing-B34h5e3Z.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"xwing-CQmQX6hn.mjs","names":["hybridCipher"],"sources":["../src/hybrid-crypto/xwing.ts"],"sourcesContent":["import { ml_kem768_x25519 as hybridCipher } from '@noble/post-quantum/hybrid.js';\nimport { HybridKeyPair } from '../types';\n\nexport function genHybridKeys(seed?: Uint8Array): HybridKeyPair {\n  return hybridCipher.keygen(seed);\n}\n\nexport function encapsulateHybrid(publicKey: Uint8Array): { cipherText: Uint8Array; sharedSecret: Uint8Array } {\n  return hybridCipher.encapsulate(publicKey);\n}\n\nexport function decapsulateHybrid(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  return hybridCipher.decapsulate(cipherText, secretKey);\n}\n"],"mappings":";;;AAGA,SAAgB,cAAc,MAAkC;AAC9D,QAAOA,iBAAa,OAAO,KAAK;;AAGlC,SAAgB,kBAAkB,WAA6E;AAC7G,QAAOA,iBAAa,YAAY,UAAU;;AAG5C,SAAgB,kBAAkB,YAAwB,WAAmC;AAC3F,QAAOA,iBAAa,YAAY,YAAY,UAAU"}
+{"version":3,"file":"xwing-B34h5e3Z.mjs","names":["hybridCipher"],"sources":["../src/hybrid-crypto/xwing.ts"],"sourcesContent":["import { ml_kem768_x25519 as hybridCipher } from '@noble/post-quantum/hybrid.js';\nimport { HybridKeyPair } from '../types';\n\nexport function genHybridKeys(seed?: Uint8Array): HybridKeyPair {\n  return hybridCipher.keygen(seed);\n}\n\nexport function encapsulateHybrid(publicKey: Uint8Array): { cipherText: Uint8Array; sharedSecret: Uint8Array } {\n  return hybridCipher.encapsulate(publicKey);\n}\n\nexport function decapsulateHybrid(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  return hybridCipher.decapsulate(cipherText, secretKey);\n}\n"],"mappings":";;AAGA,SAAgB,cAAc,MAAkC;AAC9D,QAAOA,iBAAa,OAAO,KAAK;;AAGlC,SAAgB,kBAAkB,WAA6E;AAC7G,QAAOA,iBAAa,YAAY,UAAU;;AAG5C,SAAgB,kBAAkB,YAAwB,WAAmC;AAC3F,QAAOA,iBAAa,YAAY,YAAY,UAAU"}