internxt-crypto 0.0.10-alpha → 0.0.11

package/dist/types.d.ts

@@ -1,102 +1,2 @@
-declare enum KeystoreType {
-    IDENTITY = "identity",
-    ENCRYPTION = "encryption",
-    RECOVERY = "recovery",
-    INDEX = "index"
-}
-type EncryptedKeystore = {
-    userID: string;
-    type: KeystoreType;
-    encryptedKeys: SymmetricCiphertext;
-};
-type User = {
-    email: string;
-    name: string;
-};
-type UserWithPublicKeys = User & {
-    publicKeys: PublicKeys;
-};
-type PublicKeys = {
-    eccPublicKey: CryptoKey;
-    kyberPublicKey: Uint8Array;
-};
-type MediaKeys = {
-    olmKey: Uint8Array;
-    pqKey: Uint8Array;
-    index: number;
-    userID: string;
-};
-type PrivateKeys = {
-    eccPrivateKey: CryptoKey;
-    kyberPrivateKey: Uint8Array;
-};
-type IdentityKeys = {
-    userPublicKey: CryptoKey;
-    userPrivateKey: CryptoKey;
-};
-type EncryptionKeys = {
-    userPublicKey: CryptoKey;
-    userPrivateKey: CryptoKey;
-    userPublicKyberKey: Uint8Array;
-    userPrivateKyberKey: Uint8Array;
-};
-type HybridEncryptedEmail = {
-    encryptedKey: HybridEncKey;
-    enc: SymmetricCiphertext;
-    recipientEmail: string;
-    params: EmailPublicParameters;
-    id: string;
-};
-type PwdProtectedEmail = {
-    encryptedKey: PwdProtectedKey;
-    enc: SymmetricCiphertext;
-    params: EmailPublicParameters;
-    id: string;
-};
-type SymmetricCiphertext = {
-    ciphertext: Uint8Array;
-    iv: Uint8Array;
-};
-type StoredEmail = {
-    params: EmailPublicParameters;
-    content: SymmetricCiphertext;
-    id: string;
-};
-type HybridEncKey = {
-    kyberCiphertext: Uint8Array;
-    encryptedKey: Uint8Array;
-};
-type PwdProtectedKey = {
-    encryptedKey: Uint8Array;
-    salt: Uint8Array;
-};
-type EmailBody = {
-    text: string;
-    attachments?: string[];
-};
-type EmailPublicParameters = {
-    subject: string;
-    createdAt: string;
-    sender: User;
-    recipient: User;
-    recipients?: User[];
-    replyToEmailID?: number;
-    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;
-}
-
-export { type Email, type EmailBody, type EmailPublicParameters, type EmailSearchResult, type EncryptedKeystore, type EncryptionKeys, type HybridEncKey, type HybridEncryptedEmail, type IdentityKeys, KeystoreType, type MailCache, type MediaKeys, type PrivateKeys, type PublicKeys, type PwdProtectedEmail, type PwdProtectedKey, type StoredEmail, type SymmetricCiphertext, type User, type UserWithPublicKeys };
+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

@@ -1,14 +1,3 @@
-'use strict';
+const require_types = require('./types-52g887Zi.js');
 
-// src/types.ts
-var KeystoreType = /* @__PURE__ */ ((KeystoreType2) => {
-  KeystoreType2["IDENTITY"] = "identity";
-  KeystoreType2["ENCRYPTION"] = "encryption";
-  KeystoreType2["RECOVERY"] = "recovery";
-  KeystoreType2["INDEX"] = "index";
-  return KeystoreType2;
-})(KeystoreType || {});
-
-exports.KeystoreType = KeystoreType;
-//# sourceMappingURL=types.js.map
-//# sourceMappingURL=types.js.map
+exports.KeystoreType = require_types.KeystoreType;

package/dist/types.mjs

@@ -1,12 +1,3 @@
-// src/types.ts
-var KeystoreType = /* @__PURE__ */ ((KeystoreType2) => {
-  KeystoreType2["IDENTITY"] = "identity";
-  KeystoreType2["ENCRYPTION"] = "encryption";
-  KeystoreType2["RECOVERY"] = "recovery";
-  KeystoreType2["INDEX"] = "index";
-  return KeystoreType2;
-})(KeystoreType || {});
+import { t as KeystoreType } from "./types-BiEoleqw.mjs";
 
-export { KeystoreType };
-//# sourceMappingURL=types.mjs.map
-//# sourceMappingURL=types.mjs.map
+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

package/dist/utils-CNs3cyDj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-CNs3cyDj.js","names":["importPublicKey","exportPublicKey","bip39","wordlist","AES_KEY_BIT_LENGTH","uuid"],"sources":["../src/utils/converters.ts","../src/utils/keyConverters.ts","../src/utils/genMnemonic.ts","../src/utils/genID.ts","../src/utils/index.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 { uint8ArrayToBase64, base64ToUint8Array } from '.';\nimport { PublicKeys, PublicKeysBase64 } from '../types';\nimport { exportPublicKey, importPublicKey } from '../asymmetric-crypto';\n\n/**\n * Converts a base64 string into PublicKeys type.\n *\n * @param base64 - The base64 representation of the public key.\n * @returns The resulting PublicKeys.\n */\nexport async function base64ToPublicKey(base64: PublicKeysBase64): Promise<PublicKeys> {\n  try {\n    const eccPublicKeyBytes = base64ToUint8Array(base64.eccPublicKeyBase64);\n    const eccPublicKey = await importPublicKey(eccPublicKeyBytes);\n    const kyberPublicKey = base64ToUint8Array(base64.kyberPublicKeyBase64);\n    return {\n      eccPublicKey: eccPublicKey,\n      kyberPublicKey: kyberPublicKey,\n    };\n  } catch (error) {\n    throw new Error('Failed to convert base64 to PublicKeys', { cause: error });\n  }\n}\n\n/**\n * Converts a PublicKeys type into PublicKeysBase64.\n *\n * @param key - The PublicKeys key.\n * @returns The resulting PublicKeysBase64.\n */\nexport async function publicKeyToBase64(key: PublicKeys): Promise<PublicKeysBase64> {\n  try {\n    const eccPublicKeyArray = await exportPublicKey(key.eccPublicKey);\n    const keys = {\n      eccPublicKeyBase64: uint8ArrayToBase64(eccPublicKeyArray),\n      kyberPublicKeyBase64: uint8ArrayToBase64(key.kyberPublicKey),\n    };\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to convert key of the type PublicKeys to PublicKeysBase64', { cause: error });\n  }\n}\n","import * as bip39 from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english.js';\nimport { AES_KEY_BIT_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_BIT_LENGTH);\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","export * from './converters';\nexport * from './keyConverters';\nexport * from './genMnemonic';\nexport * from './genID';\n"],"mappings":";;;;;;;;;;;;;;;;AAQA,SAAgB,gBAAgB,OAA2B;AACzD,+CAAkB,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,+CAAkB,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;;;;;;;;;;;ACzDrC,eAAsB,kBAAkB,QAA+C;AACrF,KAAI;AAIF,SAAO;GACL,cAHmB,MAAMA,0CADD,mBAAmB,OAAO,mBAAmB,CACV;GAI3D,gBAHqB,mBAAmB,OAAO,qBAAqB;GAIrE;UACM,OAAO;AACd,QAAM,IAAI,MAAM,0CAA0C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU/E,eAAsB,kBAAkB,KAA4C;AAClF,KAAI;AAMF,SAJa;GACX,oBAAoB,mBAFI,MAAMC,0CAAgB,IAAI,aAAa,CAEN;GACzD,sBAAsB,mBAAmB,IAAI,eAAe;GAC7D;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,oEAAoE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AC/BzG,SAAgB,cAAsB;AACpC,QAAOC,aAAM,iBAAiBC,4CAAUC,qCAAmB;;;;;;;;AAS7D,SAAgB,gBAAgB,UAA8B;AAC5D,QAAOF,aAAM,kBAAkB,UAAUC,2CAAS;;;;;;;;AASpD,SAAgB,gBAAgB,OAA2B;AACzD,QAAOD,aAAM,kBAAkB,OAAOC,2CAAS;;;;;;;;;;ACvBjD,SAAgB,eAAuB;AACrC,sBAAe;;AAGjB,SAAgB,YAAY,QAA0B;AACpD,wBAAaE,OAAK;;AAGpB,SAAgB,YAAY,OAA2B;AACrD,4BAAiB,MAAM"}

package/dist/utils-DS04iUcX.mjs

@@ -0,0 +1,173 @@
+import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
+import { n as AES_KEY_BIT_LENGTH } from "./constants-kTeX-2T0.mjs";
+import { o as importPublicKey, r as exportPublicKey } from "./asymmetric-crypto-CyXsV4XT.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/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 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 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 bip39.generateMnemonic(wordlist, AES_KEY_BIT_LENGTH);
+}
+/**
+* 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
+//#region src/utils/index.ts
+var utils_exports = /* @__PURE__ */ __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
+export { bytesToMnemonic as a, base64ToPublicKey as c, base64ToUint8Array as d, hexToUint8Array as f, uint8ToUTF8 as h, uuidToBytes as i, publicKeyToBase64 as l, uint8ArrayToHex as m, bytesToUuid as n, genMnemonic as o, uint8ArrayToBase64 as p, generateUuid as r, mnemonicToBytes as s, utils_exports as t, UTF8ToUint8 as u };
+//# sourceMappingURL=utils-DS04iUcX.mjs.map

package/dist/utils-DS04iUcX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-DS04iUcX.mjs","names":["uuidv4"],"sources":["../src/utils/converters.ts","../src/utils/keyConverters.ts","../src/utils/genMnemonic.ts","../src/utils/genID.ts","../src/utils/index.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 { uint8ArrayToBase64, base64ToUint8Array } from '.';\nimport { PublicKeys, PublicKeysBase64 } from '../types';\nimport { exportPublicKey, importPublicKey } from '../asymmetric-crypto';\n\n/**\n * Converts a base64 string into PublicKeys type.\n *\n * @param base64 - The base64 representation of the public key.\n * @returns The resulting PublicKeys.\n */\nexport async function base64ToPublicKey(base64: PublicKeysBase64): Promise<PublicKeys> {\n  try {\n    const eccPublicKeyBytes = base64ToUint8Array(base64.eccPublicKeyBase64);\n    const eccPublicKey = await importPublicKey(eccPublicKeyBytes);\n    const kyberPublicKey = base64ToUint8Array(base64.kyberPublicKeyBase64);\n    return {\n      eccPublicKey: eccPublicKey,\n      kyberPublicKey: kyberPublicKey,\n    };\n  } catch (error) {\n    throw new Error('Failed to convert base64 to PublicKeys', { cause: error });\n  }\n}\n\n/**\n * Converts a PublicKeys type into PublicKeysBase64.\n *\n * @param key - The PublicKeys key.\n * @returns The resulting PublicKeysBase64.\n */\nexport async function publicKeyToBase64(key: PublicKeys): Promise<PublicKeysBase64> {\n  try {\n    const eccPublicKeyArray = await exportPublicKey(key.eccPublicKey);\n    const keys = {\n      eccPublicKeyBase64: uint8ArrayToBase64(eccPublicKeyArray),\n      kyberPublicKeyBase64: uint8ArrayToBase64(key.kyberPublicKey),\n    };\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to convert key of the type PublicKeys to PublicKeysBase64', { cause: error });\n  }\n}\n","import * as bip39 from '@scure/bip39';\nimport { wordlist } from '@scure/bip39/wordlists/english.js';\nimport { AES_KEY_BIT_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_BIT_LENGTH);\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","export * from './converters';\nexport * from './keyConverters';\nexport * from './genMnemonic';\nexport * from './genID';\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;;;;;;;;;;;ACzDrC,eAAsB,kBAAkB,QAA+C;AACrF,KAAI;AAIF,SAAO;GACL,cAHmB,MAAM,gBADD,mBAAmB,OAAO,mBAAmB,CACV;GAI3D,gBAHqB,mBAAmB,OAAO,qBAAqB;GAIrE;UACM,OAAO;AACd,QAAM,IAAI,MAAM,0CAA0C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU/E,eAAsB,kBAAkB,KAA4C;AAClF,KAAI;AAMF,SAJa;GACX,oBAAoB,mBAFI,MAAM,gBAAgB,IAAI,aAAa,CAEN;GACzD,sBAAsB,mBAAmB,IAAI,eAAe;GAC7D;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,oEAAoE,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AC/BzG,SAAgB,cAAsB;AACpC,QAAO,MAAM,iBAAiB,UAAU,mBAAmB;;;;;;;;AAS7D,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"}