internxt-crypto 0.0.9-alpha → 0.0.11

package/dist/symmetric-crypto.d.mts

@@ -0,0 +1,60 @@
+//#region src/symmetric-crypto/keys.d.ts
+/**
+ * Converts Uint8Array into CryptoKey
+ *
+ * @param keyData - The Uint8Array representation of the symmetric key
+ * @returns The resulting symmetric CryptoKey.
+ */
+declare function importSymmetricCryptoKey(keyData: Uint8Array | ArrayBuffer): Promise<CryptoKey>;
+/**
+ * Converts CryptoKey into Uint8Array
+ *
+ * @param key - The symmetric CryptoKey
+ * @returns The resulting Uint8Array.
+ */
+declare function exportSymmetricCryptoKey(key: CryptoKey): Promise<Uint8Array>;
+/**
+ * Generates symmetric CryptoKey
+ *
+ * @returns The generated CryptoKey.
+ */
+declare function genSymmetricCryptoKey(): Promise<CryptoKey>;
+/**
+ * Generates symmetric key as Uint8Array
+ *
+ * @returns The generated Uint8Array.
+ */
+declare function genSymmetricKey(): Uint8Array;
+/**
+ * Derives CryptoKey from the given key material
+ *
+ * @returns The derived CryptoKey.
+ */
+declare function deriveSymmetricCryptoKey(keyMaterial: Uint8Array): Promise<CryptoKey>;
+//#endregion
+//#region src/symmetric-crypto/aes.d.ts
+/**
+ * Symmetrically encrypts the message
+ *
+ * @param encryptionKey - The symmetric CryptoKey used for message encryption
+ * @param message - The message to encrypt
+ * @param freeField - The context of the message (required for IV generation)
+ * @param aux - The auxilary string
+ * @returns The resulting ciphertext.
+ */
+declare function encryptSymmetrically(encryptionKey: CryptoKey, message: Uint8Array, aux: Uint8Array, freeField?: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decryps symmetrically encrypted message
+ *
+ * @param encryptionKey - The symmetric CryptoKey used for message encryption
+ * @param encryptedMessage - The ciphertext
+ * @param aux - The auxilary string
+ * @returns The resulting ciphertext.
+ */
+declare function decryptSymmetrically(encryptionKey: CryptoKey, encryptedMessage: Uint8Array, aux: Uint8Array): Promise<Uint8Array>;
+declare namespace index_d_exports {
+  export { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey };
+}
+//#endregion
+export { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey, index_d_exports as t };
+//# sourceMappingURL=symmetric-crypto.d.mts.map

package/dist/symmetric-crypto.d.ts

@@ -0,0 +1,60 @@
+//#region src/symmetric-crypto/keys.d.ts
+/**
+ * Converts Uint8Array into CryptoKey
+ *
+ * @param keyData - The Uint8Array representation of the symmetric key
+ * @returns The resulting symmetric CryptoKey.
+ */
+declare function importSymmetricCryptoKey(keyData: Uint8Array | ArrayBuffer): Promise<CryptoKey>;
+/**
+ * Converts CryptoKey into Uint8Array
+ *
+ * @param key - The symmetric CryptoKey
+ * @returns The resulting Uint8Array.
+ */
+declare function exportSymmetricCryptoKey(key: CryptoKey): Promise<Uint8Array>;
+/**
+ * Generates symmetric CryptoKey
+ *
+ * @returns The generated CryptoKey.
+ */
+declare function genSymmetricCryptoKey(): Promise<CryptoKey>;
+/**
+ * Generates symmetric key as Uint8Array
+ *
+ * @returns The generated Uint8Array.
+ */
+declare function genSymmetricKey(): Uint8Array;
+/**
+ * Derives CryptoKey from the given key material
+ *
+ * @returns The derived CryptoKey.
+ */
+declare function deriveSymmetricCryptoKey(keyMaterial: Uint8Array): Promise<CryptoKey>;
+//#endregion
+//#region src/symmetric-crypto/aes.d.ts
+/**
+ * Symmetrically encrypts the message
+ *
+ * @param encryptionKey - The symmetric CryptoKey used for message encryption
+ * @param message - The message to encrypt
+ * @param freeField - The context of the message (required for IV generation)
+ * @param aux - The auxilary string
+ * @returns The resulting ciphertext.
+ */
+declare function encryptSymmetrically(encryptionKey: CryptoKey, message: Uint8Array, aux: Uint8Array, freeField?: Uint8Array): Promise<Uint8Array>;
+/**
+ * Decryps symmetrically encrypted message
+ *
+ * @param encryptionKey - The symmetric CryptoKey used for message encryption
+ * @param encryptedMessage - The ciphertext
+ * @param aux - The auxilary string
+ * @returns The resulting ciphertext.
+ */
+declare function decryptSymmetrically(encryptionKey: CryptoKey, encryptedMessage: Uint8Array, aux: Uint8Array): Promise<Uint8Array>;
+declare namespace index_d_exports {
+  export { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey };
+}
+//#endregion
+export { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey, index_d_exports as t };
+//# sourceMappingURL=symmetric-crypto.d.ts.map

package/dist/symmetric-crypto.js

@@ -0,0 +1,10 @@
+require('./hash-BoqwNkcd.js');
+const require_symmetric_crypto = require('./symmetric-crypto-D65zB396.js');
+
+exports.decryptSymmetrically = require_symmetric_crypto.decryptSymmetrically;
+exports.deriveSymmetricCryptoKey = require_symmetric_crypto.deriveSymmetricCryptoKey;
+exports.encryptSymmetrically = require_symmetric_crypto.encryptSymmetrically;
+exports.exportSymmetricCryptoKey = require_symmetric_crypto.exportSymmetricCryptoKey;
+exports.genSymmetricCryptoKey = require_symmetric_crypto.genSymmetricCryptoKey;
+exports.genSymmetricKey = require_symmetric_crypto.genSymmetricKey;
+exports.importSymmetricCryptoKey = require_symmetric_crypto.importSymmetricCryptoKey;

package/dist/symmetric-crypto.mjs

@@ -0,0 +1,4 @@
+import "./hash-CXeGAwai.mjs";
+import { a as exportSymmetricCryptoKey, c as importSymmetricCryptoKey, i as deriveSymmetricCryptoKey, n as decryptSymmetrically, o as genSymmetricCryptoKey, r as encryptSymmetrically, s as genSymmetricKey } from "./symmetric-crypto-CrdS1Che.mjs";
+
+export { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey };

package/dist/types-52g887Zi.js

@@ -0,0 +1,16 @@
+
+//#region src/types.ts
+let KeystoreType = /* @__PURE__ */ function(KeystoreType) {
+	KeystoreType["ENCRYPTION"] = "Encryption";
+	KeystoreType["RECOVERY"] = "Recovery";
+	return KeystoreType;
+}({});
+
+//#endregion
+Object.defineProperty(exports, 'KeystoreType', {
+  enumerable: true,
+  get: function () {
+    return KeystoreType;
+  }
+});
+//# sourceMappingURL=types-52g887Zi.js.map

package/dist/types-52g887Zi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-52g887Zi.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  encryptedKeys: EmailKeysEncrypted;\n};\n\nexport type User = {\n  email: string;\n  name: string;\n};\n\nexport type UserWithPublicKeys = User & {\n  publicKeys: PublicKeys;\n};\n\nexport type PublicKeys = {\n  eccPublicKey: CryptoKey;\n  kyberPublicKey: Uint8Array;\n};\n\nexport type PublicKeysBase64 = {\n  eccPublicKeyBase64: string;\n  kyberPublicKeyBase64: string;\n};\n\nexport type PrivateKeys = {\n  eccPrivateKey: CryptoKey;\n  kyberPrivateKey: Uint8Array;\n};\n\nexport type PrivateKeysEncrypted = {\n  eccPrivateKeyBase64: string;\n  kyberPrivateKeyBase64: string;\n};\n\nexport type EmailKeys = {\n  publicKeys: PublicKeys;\n  privateKeys: PrivateKeys;\n};\n\nexport type EmailKeysEncrypted = {\n  publicKeys: PublicKeysBase64;\n  privateKeys: PrivateKeysEncrypted;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  enc: EmailBodyEncrypted;\n  recipientEmail: string;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type StoredEmail = {\n  params: EmailPublicParameters;\n  enc: EmailBodyEncrypted;\n  id: string;\n};\n\nexport type HybridEncKey = {\n  kyberCiphertext: string;\n  encryptedKey: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  attachments?: string[];\n};\n\nexport type EmailPublicParameters = {\n  subject: string;\n  createdAt: string;\n  sender: User;\n  recipient: User;\n  recipients?: User[];\n  replyToEmailID?: string;\n  labels?: string[];\n};\n\nexport type Email = {\n  id: string;\n  body: EmailBody;\n  params: EmailPublicParameters;\n};\n\nexport interface MailCache<Email> {\n  esCache: Map<string, Email>;\n  cacheSize: number;\n  isCacheLimited: boolean;\n  isCacheReady: boolean;\n}\nexport interface EmailSearchResult {\n  email: Email;\n  score?: number;\n}\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";;AAmHA,IAAY,sDAAL;AACL;AACA"}

package/dist/types-BiEoleqw.mjs

@@ -0,0 +1,10 @@
+//#region src/types.ts
+let KeystoreType = /* @__PURE__ */ function(KeystoreType) {
+	KeystoreType["ENCRYPTION"] = "Encryption";
+	KeystoreType["RECOVERY"] = "Recovery";
+	return KeystoreType;
+}({});
+
+//#endregion
+export { KeystoreType as t };
+//# sourceMappingURL=types-BiEoleqw.mjs.map

package/dist/types-BiEoleqw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BiEoleqw.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  encryptedKeys: EmailKeysEncrypted;\n};\n\nexport type User = {\n  email: string;\n  name: string;\n};\n\nexport type UserWithPublicKeys = User & {\n  publicKeys: PublicKeys;\n};\n\nexport type PublicKeys = {\n  eccPublicKey: CryptoKey;\n  kyberPublicKey: Uint8Array;\n};\n\nexport type PublicKeysBase64 = {\n  eccPublicKeyBase64: string;\n  kyberPublicKeyBase64: string;\n};\n\nexport type PrivateKeys = {\n  eccPrivateKey: CryptoKey;\n  kyberPrivateKey: Uint8Array;\n};\n\nexport type PrivateKeysEncrypted = {\n  eccPrivateKeyBase64: string;\n  kyberPrivateKeyBase64: string;\n};\n\nexport type EmailKeys = {\n  publicKeys: PublicKeys;\n  privateKeys: PrivateKeys;\n};\n\nexport type EmailKeysEncrypted = {\n  publicKeys: PublicKeysBase64;\n  privateKeys: PrivateKeysEncrypted;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  enc: EmailBodyEncrypted;\n  recipientEmail: string;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type StoredEmail = {\n  params: EmailPublicParameters;\n  enc: EmailBodyEncrypted;\n  id: string;\n};\n\nexport type HybridEncKey = {\n  kyberCiphertext: string;\n  encryptedKey: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  attachments?: string[];\n};\n\nexport type EmailPublicParameters = {\n  subject: string;\n  createdAt: string;\n  sender: User;\n  recipient: User;\n  recipients?: User[];\n  replyToEmailID?: string;\n  labels?: string[];\n};\n\nexport type Email = {\n  id: string;\n  body: EmailBody;\n  params: EmailPublicParameters;\n};\n\nexport interface MailCache<Email> {\n  esCache: Map<string, Email>;\n  cacheSize: number;\n  isCacheLimited: boolean;\n  isCacheReady: boolean;\n}\nexport interface EmailSearchResult {\n  email: Email;\n  score?: number;\n}\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";AAmHA,IAAY,sDAAL;AACL;AACA"}

package/dist/types-Ds3ivE9W.d.ts

@@ -0,0 +1,104 @@
+//#region src/types.d.ts
+type EncryptedKeystore = {
+  userEmail: string;
+  type: KeystoreType;
+  encryptedKeys: EmailKeysEncrypted;
+};
+type User = {
+  email: string;
+  name: string;
+};
+type UserWithPublicKeys = User & {
+  publicKeys: PublicKeys;
+};
+type PublicKeys = {
+  eccPublicKey: CryptoKey;
+  kyberPublicKey: Uint8Array;
+};
+type PublicKeysBase64 = {
+  eccPublicKeyBase64: string;
+  kyberPublicKeyBase64: string;
+};
+type PrivateKeys = {
+  eccPrivateKey: CryptoKey;
+  kyberPrivateKey: Uint8Array;
+};
+type PrivateKeysEncrypted = {
+  eccPrivateKeyBase64: string;
+  kyberPrivateKeyBase64: string;
+};
+type EmailKeys = {
+  publicKeys: PublicKeys;
+  privateKeys: PrivateKeys;
+};
+type EmailKeysEncrypted = {
+  publicKeys: PublicKeysBase64;
+  privateKeys: PrivateKeysEncrypted;
+};
+type HybridEncryptedEmail = {
+  encryptedKey: HybridEncKey;
+  enc: EmailBodyEncrypted;
+  recipientEmail: string;
+  params: EmailPublicParameters;
+  id: string;
+  isSubjectEncrypted: boolean;
+};
+type PwdProtectedEmail = {
+  encryptedKey: PwdProtectedKey;
+  enc: EmailBodyEncrypted;
+  params: EmailPublicParameters;
+  id: string;
+  isSubjectEncrypted: boolean;
+};
+type StoredEmail = {
+  params: EmailPublicParameters;
+  enc: EmailBodyEncrypted;
+  id: string;
+};
+type HybridEncKey = {
+  kyberCiphertext: string;
+  encryptedKey: string;
+};
+type PwdProtectedKey = {
+  encryptedKey: string;
+  salt: string;
+};
+type EmailBodyEncrypted = {
+  encText: string;
+  encAttachments?: string[];
+};
+type EmailBody = {
+  text: string;
+  attachments?: string[];
+};
+type EmailPublicParameters = {
+  subject: string;
+  createdAt: string;
+  sender: User;
+  recipient: User;
+  recipients?: User[];
+  replyToEmailID?: string;
+  labels?: string[];
+};
+type Email = {
+  id: string;
+  body: EmailBody;
+  params: EmailPublicParameters;
+};
+interface MailCache<Email> {
+  esCache: Map<string, Email>;
+  cacheSize: number;
+  isCacheLimited: boolean;
+  isCacheReady: boolean;
+}
+interface EmailSearchResult {
+  email: Email;
+  score?: number;
+}
+declare enum KeystoreType {
+  ENCRYPTION = "Encryption",
+  RECOVERY = "Recovery"
+}
+//#endregion
+export { PwdProtectedEmail as _, EmailKeysEncrypted as a, User as b, EncryptedKeystore as c, KeystoreType as d, MailCache as f, PublicKeysBase64 as g, PublicKeys as h, EmailKeys as i, HybridEncKey as l, PrivateKeysEncrypted as m, EmailBody as n, EmailPublicParameters as o, PrivateKeys as p, EmailBodyEncrypted as r, EmailSearchResult as s, Email as t, HybridEncryptedEmail as u, PwdProtectedKey as v, UserWithPublicKeys as x, StoredEmail as y };
+//# sourceMappingURL=types-Ds3ivE9W.d.ts.map

package/dist/types-DwQJtrTx.d.mts

@@ -0,0 +1,104 @@
+//#region src/types.d.ts
+type EncryptedKeystore = {
+  userEmail: string;
+  type: KeystoreType;
+  encryptedKeys: EmailKeysEncrypted;
+};
+type User = {
+  email: string;
+  name: string;
+};
+type UserWithPublicKeys = User & {
+  publicKeys: PublicKeys;
+};
+type PublicKeys = {
+  eccPublicKey: CryptoKey;
+  kyberPublicKey: Uint8Array;
+};
+type PublicKeysBase64 = {
+  eccPublicKeyBase64: string;
+  kyberPublicKeyBase64: string;
+};
+type PrivateKeys = {
+  eccPrivateKey: CryptoKey;
+  kyberPrivateKey: Uint8Array;
+};
+type PrivateKeysEncrypted = {
+  eccPrivateKeyBase64: string;
+  kyberPrivateKeyBase64: string;
+};
+type EmailKeys = {
+  publicKeys: PublicKeys;
+  privateKeys: PrivateKeys;
+};
+type EmailKeysEncrypted = {
+  publicKeys: PublicKeysBase64;
+  privateKeys: PrivateKeysEncrypted;
+};
+type HybridEncryptedEmail = {
+  encryptedKey: HybridEncKey;
+  enc: EmailBodyEncrypted;
+  recipientEmail: string;
+  params: EmailPublicParameters;
+  id: string;
+  isSubjectEncrypted: boolean;
+};
+type PwdProtectedEmail = {
+  encryptedKey: PwdProtectedKey;
+  enc: EmailBodyEncrypted;
+  params: EmailPublicParameters;
+  id: string;
+  isSubjectEncrypted: boolean;
+};
+type StoredEmail = {
+  params: EmailPublicParameters;
+  enc: EmailBodyEncrypted;
+  id: string;
+};
+type HybridEncKey = {
+  kyberCiphertext: string;
+  encryptedKey: string;
+};
+type PwdProtectedKey = {
+  encryptedKey: string;
+  salt: string;
+};
+type EmailBodyEncrypted = {
+  encText: string;
+  encAttachments?: string[];
+};
+type EmailBody = {
+  text: string;
+  attachments?: string[];
+};
+type EmailPublicParameters = {
+  subject: string;
+  createdAt: string;
+  sender: User;
+  recipient: User;
+  recipients?: User[];
+  replyToEmailID?: string;
+  labels?: string[];
+};
+type Email = {
+  id: string;
+  body: EmailBody;
+  params: EmailPublicParameters;
+};
+interface MailCache<Email> {
+  esCache: Map<string, Email>;
+  cacheSize: number;
+  isCacheLimited: boolean;
+  isCacheReady: boolean;
+}
+interface EmailSearchResult {
+  email: Email;
+  score?: number;
+}
+declare enum KeystoreType {
+  ENCRYPTION = "Encryption",
+  RECOVERY = "Recovery"
+}
+//#endregion
+export { PwdProtectedEmail as _, EmailKeysEncrypted as a, User as b, EncryptedKeystore as c, KeystoreType as d, MailCache as f, PublicKeysBase64 as g, PublicKeys as h, EmailKeys as i, HybridEncKey as l, PrivateKeysEncrypted as m, EmailBody as n, EmailPublicParameters as o, PrivateKeys as p, EmailBodyEncrypted as r, EmailSearchResult as s, Email as t, HybridEncryptedEmail as u, PwdProtectedKey as v, UserWithPublicKeys as x, StoredEmail as y };
+//# sourceMappingURL=types-DwQJtrTx.d.mts.map

package/dist/types.d.mts

@@ -0,0 +1,2 @@
+import { _ as PwdProtectedEmail, a as EmailKeysEncrypted, b as User, c as EncryptedKeystore, d as KeystoreType, f as MailCache, g as PublicKeysBase64, h as PublicKeys, i as EmailKeys, l as HybridEncKey, m as PrivateKeysEncrypted, n as EmailBody, o as EmailPublicParameters, p as PrivateKeys, r as EmailBodyEncrypted, s as EmailSearchResult, t as Email, u as HybridEncryptedEmail, v as PwdProtectedKey, x as UserWithPublicKeys, y as StoredEmail } from "./types-DwQJtrTx.mjs";
+export { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys };

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { _ as PwdProtectedEmail, a as EmailKeysEncrypted, b as User, c as EncryptedKeystore, d as KeystoreType, f as MailCache, g as PublicKeysBase64, h as PublicKeys, i as EmailKeys, l as HybridEncKey, m as PrivateKeysEncrypted, n as EmailBody, o as EmailPublicParameters, p as PrivateKeys, r as EmailBodyEncrypted, s as EmailSearchResult, t as Email, u as HybridEncryptedEmail, v as PwdProtectedKey, x as UserWithPublicKeys, y as StoredEmail } from "./types-Ds3ivE9W.js";
+export { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys };

package/dist/types.js

@@ -0,0 +1,3 @@
+const require_types = require('./types-52g887Zi.js');
+
+exports.KeystoreType = require_types.KeystoreType;

package/dist/types.mjs

@@ -0,0 +1,3 @@
+import { t as KeystoreType } from "./types-BiEoleqw.mjs";
+
+export { KeystoreType };

package/dist/utils-CNs3cyDj.js

@@ -0,0 +1,263 @@
+const require_chunk = require('./chunk-Dt-PWiN7.js');
+const require_constants = require('./constants-Ccp21E03.js');
+const require_asymmetric_crypto = require('./asymmetric-crypto-BORmLhnx.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/keyConverters.ts
+/**
+* Converts a base64 string into PublicKeys type.
+*
+* @param base64 - The base64 representation of the public key.
+* @returns The resulting PublicKeys.
+*/
+async function base64ToPublicKey(base64) {
+	try {
+		return {
+			eccPublicKey: await require_asymmetric_crypto.importPublicKey(base64ToUint8Array(base64.eccPublicKeyBase64)),
+			kyberPublicKey: base64ToUint8Array(base64.kyberPublicKeyBase64)
+		};
+	} catch (error) {
+		throw new Error("Failed to convert base64 to PublicKeys", { cause: error });
+	}
+}
+/**
+* Converts a PublicKeys type into PublicKeysBase64.
+*
+* @param key - The PublicKeys key.
+* @returns The resulting PublicKeysBase64.
+*/
+async function publicKeyToBase64(key) {
+	try {
+		return {
+			eccPublicKeyBase64: uint8ArrayToBase64(await require_asymmetric_crypto.exportPublicKey(key.eccPublicKey)),
+			kyberPublicKeyBase64: uint8ArrayToBase64(key.kyberPublicKey)
+		};
+	} catch (error) {
+		throw new Error("Failed to convert key of the type PublicKeys to PublicKeysBase64", { cause: error });
+	}
+}
+
+//#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, require_constants.AES_KEY_BIT_LENGTH);
+}
+/**
+* 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
+//#region src/utils/index.ts
+var utils_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	UTF8ToUint8: () => UTF8ToUint8,
+	base64ToPublicKey: () => base64ToPublicKey,
+	base64ToUint8Array: () => base64ToUint8Array,
+	bytesToMnemonic: () => bytesToMnemonic,
+	bytesToUuid: () => bytesToUuid,
+	genMnemonic: () => genMnemonic,
+	generateUuid: () => generateUuid,
+	hexToUint8Array: () => hexToUint8Array,
+	mnemonicToBytes: () => mnemonicToBytes,
+	publicKeyToBase64: () => publicKeyToBase64,
+	uint8ArrayToBase64: () => uint8ArrayToBase64,
+	uint8ArrayToHex: () => uint8ArrayToHex,
+	uint8ToUTF8: () => uint8ToUTF8,
+	uuidToBytes: () => uuidToBytes
+});
+
+//#endregion
+Object.defineProperty(exports, 'UTF8ToUint8', {
+  enumerable: true,
+  get: function () {
+    return UTF8ToUint8;
+  }
+});
+Object.defineProperty(exports, 'base64ToPublicKey', {
+  enumerable: true,
+  get: function () {
+    return base64ToPublicKey;
+  }
+});
+Object.defineProperty(exports, 'base64ToUint8Array', {
+  enumerable: true,
+  get: function () {
+    return base64ToUint8Array;
+  }
+});
+Object.defineProperty(exports, 'bytesToMnemonic', {
+  enumerable: true,
+  get: function () {
+    return bytesToMnemonic;
+  }
+});
+Object.defineProperty(exports, 'bytesToUuid', {
+  enumerable: true,
+  get: function () {
+    return bytesToUuid;
+  }
+});
+Object.defineProperty(exports, 'genMnemonic', {
+  enumerable: true,
+  get: function () {
+    return genMnemonic;
+  }
+});
+Object.defineProperty(exports, 'generateUuid', {
+  enumerable: true,
+  get: function () {
+    return generateUuid;
+  }
+});
+Object.defineProperty(exports, 'hexToUint8Array', {
+  enumerable: true,
+  get: function () {
+    return hexToUint8Array;
+  }
+});
+Object.defineProperty(exports, 'mnemonicToBytes', {
+  enumerable: true,
+  get: function () {
+    return mnemonicToBytes;
+  }
+});
+Object.defineProperty(exports, 'publicKeyToBase64', {
+  enumerable: true,
+  get: function () {
+    return publicKeyToBase64;
+  }
+});
+Object.defineProperty(exports, 'uint8ArrayToBase64', {
+  enumerable: true,
+  get: function () {
+    return uint8ArrayToBase64;
+  }
+});
+Object.defineProperty(exports, 'uint8ArrayToHex', {
+  enumerable: true,
+  get: function () {
+    return uint8ArrayToHex;
+  }
+});
+Object.defineProperty(exports, 'uint8ToUTF8', {
+  enumerable: true,
+  get: function () {
+    return uint8ToUTF8;
+  }
+});
+Object.defineProperty(exports, 'utils_exports', {
+  enumerable: true,
+  get: function () {
+    return utils_exports;
+  }
+});
+Object.defineProperty(exports, 'uuidToBytes', {
+  enumerable: true,
+  get: function () {
+    return uuidToBytes;
+  }
+});
+//# sourceMappingURL=utils-CNs3cyDj.js.map