internxt-crypto 1.2.0 → 1.3.1

package/dist/storage-service.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"storage-service.mjs","names":["get","set","removeItem","exists","clear"],"sources":["../src/storage-service/localStorageService.ts","../src/storage-service/sessionStorageService.ts"],"sourcesContent":["function get(key: string): string | null {\n  return localStorage.getItem(key);\n}\n\nfunction set(key: string, value: string): void {\n  return localStorage.setItem(key, value);\n}\n\nfunction removeItem(key: string): void {\n  localStorage.removeItem(key);\n}\n\nfunction exists(key: string): boolean {\n  return !!localStorage.getItem(key);\n}\n\nfunction clear(): void {\n  localStorage.clear();\n}\n\nconst localStorageService = {\n  set,\n  get,\n  removeItem,\n  exists,\n  clear,\n};\n\nexport default localStorageService;\n\nexport interface LocalStorageService {\n  set: (key: string, value: string) => void;\n  get: (key: string) => string | null;\n  removeItem: (key: string) => void;\n  exists: (key: string) => boolean;\n  clear: () => void;\n}\n","function get(key: string): string | null {\n  return sessionStorage.getItem(key);\n}\n\nfunction set(key: string, value: string): void {\n  return sessionStorage.setItem(key, value);\n}\n\nfunction removeItem(key: string): void {\n  sessionStorage.removeItem(key);\n}\n\nfunction exists(key: string): boolean {\n  return !!sessionStorage.getItem(key);\n}\n\nfunction clear(): void {\n  sessionStorage.clear();\n}\n\nconst sessionStorageService = {\n  set,\n  get,\n  removeItem,\n  exists,\n  clear,\n};\n\nexport default sessionStorageService;\n\nexport interface SessionStorageService {\n  set: (key: string, value: string) => void;\n  get: (key: string) => string | null;\n  removeItem: (key: string) => void;\n  exists: (key: string) => boolean;\n  clear: () => void;\n}\n"],"mappings":";;;;AAAA,SAASA,MAAI,KAA4B;AACvC,QAAO,aAAa,QAAQ,IAAI;;AAGlC,SAASC,MAAI,KAAa,OAAqB;AAC7C,QAAO,aAAa,QAAQ,KAAK,MAAM;;AAGzC,SAASC,aAAW,KAAmB;AACrC,cAAa,WAAW,IAAI;;AAG9B,SAASC,SAAO,KAAsB;AACpC,QAAO,CAAC,CAAC,aAAa,QAAQ,IAAI;;AAGpC,SAASC,UAAc;AACrB,cAAa,OAAO;;AAGtB,MAAM,sBAAsB;CAC1B;CACA;CACA;CACA;CACA;CACD;;;;;AC1BD,SAAS,IAAI,KAA4B;AACvC,QAAO,eAAe,QAAQ,IAAI;;AAGpC,SAAS,IAAI,KAAa,OAAqB;AAC7C,QAAO,eAAe,QAAQ,KAAK,MAAM;;AAG3C,SAAS,WAAW,KAAmB;AACrC,gBAAe,WAAW,IAAI;;AAGhC,SAAS,OAAO,KAAsB;AACpC,QAAO,CAAC,CAAC,eAAe,QAAQ,IAAI;;AAGtC,SAAS,QAAc;AACrB,gBAAe,OAAO;;AAGxB,MAAM,wBAAwB;CAC5B;CACA;CACA;CACA;CACA;CACD"}
+{"version":3,"file":"storage-service.mjs","names":["get","set","removeItem","exists","clear"],"sources":["../src/storage-service/localStorageService.ts","../src/storage-service/sessionStorageService.ts"],"sourcesContent":["function get(key: string): string | null {\n  return localStorage.getItem(key);\n}\n\nfunction set(key: string, value: string): void {\n  return localStorage.setItem(key, value);\n}\n\nfunction removeItem(key: string): void {\n  localStorage.removeItem(key);\n}\n\nfunction exists(key: string): boolean {\n  return !!localStorage.getItem(key);\n}\n\nfunction clear(): void {\n  localStorage.clear();\n}\n\nconst localStorageService = {\n  set,\n  get,\n  removeItem,\n  exists,\n  clear,\n};\n\nexport default localStorageService;\n\nexport interface LocalStorageService {\n  set: (key: string, value: string) => void;\n  get: (key: string) => string | null;\n  removeItem: (key: string) => void;\n  exists: (key: string) => boolean;\n  clear: () => void;\n}\n","function get(key: string): string | null {\n  return sessionStorage.getItem(key);\n}\n\nfunction set(key: string, value: string): void {\n  return sessionStorage.setItem(key, value);\n}\n\nfunction removeItem(key: string): void {\n  sessionStorage.removeItem(key);\n}\n\nfunction exists(key: string): boolean {\n  return !!sessionStorage.getItem(key);\n}\n\nfunction clear(): void {\n  sessionStorage.clear();\n}\n\nconst sessionStorageService = {\n  set,\n  get,\n  removeItem,\n  exists,\n  clear,\n};\n\nexport default sessionStorageService;\n\nexport interface SessionStorageService {\n  set: (key: string, value: string) => void;\n  get: (key: string) => string | null;\n  removeItem: (key: string) => void;\n  exists: (key: string) => boolean;\n  clear: () => void;\n}\n"],"mappings":";;;AAAA,SAASA,MAAI,KAA4B;AACvC,QAAO,aAAa,QAAQ,IAAI;;AAGlC,SAASC,MAAI,KAAa,OAAqB;AAC7C,QAAO,aAAa,QAAQ,KAAK,MAAM;;AAGzC,SAASC,aAAW,KAAmB;AACrC,cAAa,WAAW,IAAI;;AAG9B,SAASC,SAAO,KAAsB;AACpC,QAAO,CAAC,CAAC,aAAa,QAAQ,IAAI;;AAGpC,SAASC,UAAc;AACrB,cAAa,OAAO;;AAGtB,MAAM,sBAAsB;CAC1B,KAAA;CACA,KAAA;CACA,YAAA;CACA,QAAA;CACA,OAAA;CACD;;;;AC1BD,SAAS,IAAI,KAA4B;AACvC,QAAO,eAAe,QAAQ,IAAI;;AAGpC,SAAS,IAAI,KAAa,OAAqB;AAC7C,QAAO,eAAe,QAAQ,KAAK,MAAM;;AAG3C,SAAS,WAAW,KAAmB;AACrC,gBAAe,WAAW,IAAI;;AAGhC,SAAS,OAAO,KAAsB;AACpC,QAAO,CAAC,CAAC,eAAe,QAAQ,IAAI;;AAGtC,SAAS,QAAc;AACrB,gBAAe,OAAO;;AAGxB,MAAM,wBAAwB;CAC5B;CACA;CACA;CACA;CACA;CACD"}

package/dist/symmetric-crypto.js

@@ -1,6 +1,52 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_aes = require('./aes-CuW_SPl-.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./chunk-C13QxCFV.js");
+require("./constants.js");
+let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
+let _noble_ciphers_webcrypto_js = require("@noble/ciphers/webcrypto.js");
+//#region src/symmetric-crypto/aes.ts
+/**
+* Symmetrically encrypts the message
+*
+* @param encryptionKey - The symmetric key used for message encryption
+* @param message - The message to encrypt
+* @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.
+* @returns The resulting ciphertext.
+*/
+async function encryptSymmetrically(encryptionKey, message, aux) {
+	try {
+		const iv = (0, _noble_hashes_utils_js.randomBytes)(12);
+		return (0, _noble_hashes_utils_js.concatBytes)(await (0, _noble_ciphers_webcrypto_js.gcm)(encryptionKey, iv, aux).encrypt(message), iv);
+	} catch (error) {
+		throw new Error("Failed to encrypt symmetrically", { cause: error });
+	}
+}
+/**
+* Decryps symmetrically encrypted message
+*
+* @param encryptionKey - The symmetric key used for message encryption
+* @param encryptedMessage - The ciphertext
+* @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.
+* @returns The resulting ciphertext.
+*/
+async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
+	try {
+		const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - 12);
+		return await (0, _noble_ciphers_webcrypto_js.gcm)(encryptionKey, encryptedMessage.slice(encryptedMessage.length - 12), aux).decrypt(ciphertext);
+	} catch (error) {
+		throw new Error("Failed to decrypt symmetrically", { cause: error });
+	}
+}
+/**
+* Generates symmetric key as Uint8Array
+*
+* @returns The generated Uint8Array.
+*/
+function genSymmetricKey() {
+	return (0, _noble_hashes_utils_js.randomBytes)(32);
+}
+//#endregion
+exports.decryptSymmetrically = decryptSymmetrically;
+exports.encryptSymmetrically = encryptSymmetrically;
+exports.genSymmetricKey = genSymmetricKey;
 
-exports.decryptSymmetrically = require_aes.decryptSymmetrically;
-exports.encryptSymmetrically = require_aes.encryptSymmetrically;
-exports.genSymmetricKey = require_aes.genSymmetricKey;
+//# sourceMappingURL=symmetric-crypto.js.map

package/dist/symmetric-crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symmetric-crypto.js","names":[],"sources":["../src/symmetric-crypto/aes.ts"],"sourcesContent":["import { concatBytes, randomBytes } from '@noble/hashes/utils.js';\nimport { IV_LEN_BYTES, AES_KEY_BYTE_LENGTH } from '../constants';\nimport { gcm as aeadCipher } from '@noble/ciphers/webcrypto.js';\n\n/**\n * Symmetrically encrypts the message\n *\n * @param encryptionKey - The symmetric key used for message encryption\n * @param message - The message to encrypt\n * @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.\n * @returns The resulting ciphertext.\n */\nexport async function encryptSymmetrically(\n  encryptionKey: Uint8Array,\n  message: Uint8Array,\n  aux?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const iv = randomBytes(IV_LEN_BYTES);\n    const ciphertext = await aeadCipher(encryptionKey, iv, aux).encrypt(message);\n    return concatBytes(ciphertext, iv);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Decryps symmetrically encrypted message\n *\n * @param encryptionKey - The symmetric key used for message encryption\n * @param encryptedMessage - The ciphertext\n * @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.\n * @returns The resulting ciphertext.\n */\nexport async function decryptSymmetrically(\n  encryptionKey: Uint8Array,\n  encryptedMessage: Uint8Array,\n  aux?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - IV_LEN_BYTES);\n    const iv = encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES);\n    const result = await aeadCipher(encryptionKey, iv, aux).decrypt(ciphertext);\n    return result;\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Generates symmetric key as Uint8Array\n *\n * @returns The generated Uint8Array.\n */\nexport function genSymmetricKey(): Uint8Array {\n  return randomBytes(AES_KEY_BYTE_LENGTH);\n}\n"],"mappings":";;;;;;;;;;;;;;AAYA,eAAsB,qBACpB,eACA,SACA,KACqB;AACrB,KAAI;EACF,MAAM,MAAA,GAAA,uBAAA,aAAA,GAA8B;AAEpC,UAAA,GAAA,uBAAA,aAAmB,OAAA,GAAA,4BAAA,KADiB,eAAe,IAAI,IAAI,CAAC,QAAQ,QAAQ,EAC7C,GAAG;UAC3B,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYxE,eAAsB,qBACpB,eACA,kBACA,KACqB;AACrB,KAAI;EACF,MAAM,aAAa,iBAAiB,MAAM,GAAG,iBAAiB,SAAA,GAAsB;AAGpF,SAAO,OAAA,GAAA,4BAAA,KADyB,eADrB,iBAAiB,MAAM,iBAAiB,SAAA,GACF,EAAE,IAAI,CAAC,QAAQ,WAAW;UAEpE,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASxE,SAAgB,kBAA8B;AAC5C,SAAA,GAAA,uBAAA,aAAA,GAAuC"}

package/dist/symmetric-crypto.mjs

@@ -1,3 +1,48 @@
-import { n as encryptSymmetrically, r as genSymmetricKey, t as decryptSymmetrically } from "./aes-B8TA-JKq.mjs";
+import "./constants.mjs";
+import { concatBytes, randomBytes } from "@noble/hashes/utils.js";
+import { gcm } from "@noble/ciphers/webcrypto.js";
+//#region src/symmetric-crypto/aes.ts
+/**
+* Symmetrically encrypts the message
+*
+* @param encryptionKey - The symmetric key used for message encryption
+* @param message - The message to encrypt
+* @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.
+* @returns The resulting ciphertext.
+*/
+async function encryptSymmetrically(encryptionKey, message, aux) {
+	try {
+		const iv = randomBytes(12);
+		return concatBytes(await gcm(encryptionKey, iv, aux).encrypt(message), iv);
+	} catch (error) {
+		throw new Error("Failed to encrypt symmetrically", { cause: error });
+	}
+}
+/**
+* Decryps symmetrically encrypted message
+*
+* @param encryptionKey - The symmetric key used for message encryption
+* @param encryptedMessage - The ciphertext
+* @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.
+* @returns The resulting ciphertext.
+*/
+async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
+	try {
+		const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - 12);
+		return await gcm(encryptionKey, encryptedMessage.slice(encryptedMessage.length - 12), aux).decrypt(ciphertext);
+	} catch (error) {
+		throw new Error("Failed to decrypt symmetrically", { cause: error });
+	}
+}
+/**
+* Generates symmetric key as Uint8Array
+*
+* @returns The generated Uint8Array.
+*/
+function genSymmetricKey() {
+	return randomBytes(32);
+}
+//#endregion
+export { decryptSymmetrically, encryptSymmetrically, genSymmetricKey };
 
-export { decryptSymmetrically, encryptSymmetrically, genSymmetricKey };
+//# sourceMappingURL=symmetric-crypto.mjs.map

package/dist/symmetric-crypto.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"symmetric-crypto.mjs","names":["aeadCipher"],"sources":["../src/symmetric-crypto/aes.ts"],"sourcesContent":["import { concatBytes, randomBytes } from '@noble/hashes/utils.js';\nimport { IV_LEN_BYTES, AES_KEY_BYTE_LENGTH } from '../constants';\nimport { gcm as aeadCipher } from '@noble/ciphers/webcrypto.js';\n\n/**\n * Symmetrically encrypts the message\n *\n * @param encryptionKey - The symmetric key used for message encryption\n * @param message - The message to encrypt\n * @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.\n * @returns The resulting ciphertext.\n */\nexport async function encryptSymmetrically(\n  encryptionKey: Uint8Array,\n  message: Uint8Array,\n  aux?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const iv = randomBytes(IV_LEN_BYTES);\n    const ciphertext = await aeadCipher(encryptionKey, iv, aux).encrypt(message);\n    return concatBytes(ciphertext, iv);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Decryps symmetrically encrypted message\n *\n * @param encryptionKey - The symmetric key used for message encryption\n * @param encryptedMessage - The ciphertext\n * @param aux - The auxilary string (e.g., context string or timestamp) for AEAD.\n * @returns The resulting ciphertext.\n */\nexport async function decryptSymmetrically(\n  encryptionKey: Uint8Array,\n  encryptedMessage: Uint8Array,\n  aux?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - IV_LEN_BYTES);\n    const iv = encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES);\n    const result = await aeadCipher(encryptionKey, iv, aux).decrypt(ciphertext);\n    return result;\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Generates symmetric key as Uint8Array\n *\n * @returns The generated Uint8Array.\n */\nexport function genSymmetricKey(): Uint8Array {\n  return randomBytes(AES_KEY_BYTE_LENGTH);\n}\n"],"mappings":";;;;;;;;;;;;AAYA,eAAsB,qBACpB,eACA,SACA,KACqB;AACrB,KAAI;EACF,MAAM,KAAK,YAAA,GAAyB;AAEpC,SAAO,YAAY,MADMA,IAAW,eAAe,IAAI,IAAI,CAAC,QAAQ,QAAQ,EAC7C,GAAG;UAC3B,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYxE,eAAsB,qBACpB,eACA,kBACA,KACqB;AACrB,KAAI;EACF,MAAM,aAAa,iBAAiB,MAAM,GAAG,iBAAiB,SAAA,GAAsB;AAGpF,SAAO,MADcA,IAAW,eADrB,iBAAiB,MAAM,iBAAiB,SAAA,GACF,EAAE,IAAI,CAAC,QAAQ,WAAW;UAEpE,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASxE,SAAgB,kBAA8B;AAC5C,QAAO,YAAA,GAAgC"}

package/dist/types-4P0WII1D.d.ts

@@ -0,0 +1,49 @@
+//#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 { HybridEncryptedEmail as a, PwdProtectedEmail as c, HybridEncKey as i, PwdProtectedKey as l, EmailBodyEncrypted as n, HybridKeyPair as o, EncryptedKeystore as r, KeystoreType as s, EmailBody as t, RecipientWithPublicKey as u };
+//# sourceMappingURL=types-4P0WII1D.d.ts.map

package/dist/types-4P0WII1D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-4P0WII1D.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,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,YAAA;EACV,gBAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,UAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,OAAA;EACA,WAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}

package/dist/types-DAPJQG8U.d.mts

@@ -0,0 +1,49 @@
+//#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 { HybridEncryptedEmail as a, PwdProtectedEmail as c, HybridEncKey as i, PwdProtectedKey as l, EmailBodyEncrypted as n, HybridKeyPair as o, EncryptedKeystore as r, KeystoreType as s, EmailBody as t, RecipientWithPublicKey as u };
+//# sourceMappingURL=types-DAPJQG8U.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-DAPJQG8U.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,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,YAAA;EACV,gBAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,UAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,OAAA;EACA,WAAA;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 HybridEncryptedEmail, c as PwdProtectedEmail, i as HybridEncKey, l as PwdProtectedKey, n as EmailBodyEncrypted, o as HybridKeyPair, r as EncryptedKeystore, s as KeystoreType, t as EmailBody, u as RecipientWithPublicKey } from "./types-DAPJQG8U.mjs";
+export { EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, PwdProtectedEmail, 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 HybridEncryptedEmail, c as PwdProtectedEmail, i as HybridEncKey, l as PwdProtectedKey, n as EmailBodyEncrypted, o as HybridKeyPair, r as EncryptedKeystore, s as KeystoreType, t as EmailBody, u as RecipientWithPublicKey } from "./types-4P0WII1D.js";
+export { EmailBody, EmailBodyEncrypted, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, PwdProtectedEmail, 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  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,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  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,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