internxt-crypto 1.3.0 → 1.3.1

package/dist/utils.js

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

package/dist/utils.js.map

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

package/dist/utils.mjs

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

package/dist/utils.mjs.map

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

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

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

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

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

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "internxt-crypto",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
@@ -19,31 +19,31 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@internxt/eslint-config-internxt": "2.0.1",
-    "@internxt/prettier-config": "https://github.com/internxt/prettier-config.git#v1.0.2",
-    "@playwright/test": "^1.54.2",
-    "@types/node": "^25.2.3",
-    "@vitest/browser-playwright": "^4.0.10",
-    "@vitest/coverage-istanbul": "^4.0.10",
-    "@vitest/coverage-v8": "^4.0.18",
-    "eslint": "^10.0.2",
-    "knip": "^5.84.0",
-    "lint-staged": "^16.1.4",
-    "playwright": "^1.54.1",
-    "prettier": "^3.6.2",
-    "tsdown": "^0.20.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.0"
+    "@internxt/eslint-config-internxt": "^2.1.0",
+    "@internxt/prettier-config": "^2.0.1",
+    "@playwright/test": "^1.59.1",
+    "@types/node": "^25.6.0",
+    "@vitest/browser-playwright": "^4.1.5",
+    "@vitest/coverage-istanbul": "^4.1.5",
+    "@vitest/coverage-v8": "^4.1.5",
+    "eslint": "^10.3.0",
+    "knip": "^6.11.0",
+    "lint-staged": "^17.0.2",
+    "playwright": "^1.59.1",
+    "prettier": "^3.8.3",
+    "tsdown": "^0.21.10",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
   },
   "dependencies": {
-    "@noble/ciphers": "^2.1.1",
-    "@noble/curves": "^2.0.1",
-    "@noble/hashes": "^2.0.1",
-    "@noble/post-quantum": "^0.5.2",
-    "@scure/bip39": "^2.0.1",
+    "@noble/ciphers": "^2.2.0",
+    "@noble/curves": "^2.2.0",
+    "@noble/hashes": "^2.2.0",
+    "@noble/post-quantum": "^0.6.1",
+    "@scure/bip39": "^2.2.0",
     "hash-wasm": "^4.12.0",
     "husky": "^9.1.7",
-    "uuid": "^13.0.0"
+    "uuid": "^14.0.0"
   },
   "exports": {
     ".": {

package/dist/aes-B8TA-JKq.mjs

@@ -1,49 +0,0 @@
-import { AES_KEY_BYTE_LENGTH, IV_LEN_BYTES } from "./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(IV_LEN_BYTES);
-		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 - IV_LEN_BYTES);
-		return await gcm(encryptionKey, encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES), 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(AES_KEY_BYTE_LENGTH);
-}
-
-//#endregion
-export { encryptSymmetrically as n, genSymmetricKey as r, decryptSymmetrically as t };
-//# sourceMappingURL=aes-B8TA-JKq.mjs.map

package/dist/aes-B8TA-JKq.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"aes-B8TA-JKq.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,YAAY,aAAa;AAEpC,SAAO,YADY,MAAMA,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,SAAS,aAAa;AAGpF,SADe,MAAMA,IAAW,eADrB,iBAAiB,MAAM,iBAAiB,SAAS,aAAa,EACtB,IAAI,CAAC,QAAQ,WAAW;UAEpE,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASxE,SAAgB,kBAA8B;AAC5C,QAAO,YAAY,oBAAoB"}

package/dist/aes-CuW_SPl-.js

@@ -1,67 +0,0 @@
-const require_chunk = require('./chunk-EbLFQX5m.js');
-const require_constants = 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)(require_constants.IV_LEN_BYTES);
-		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 - require_constants.IV_LEN_BYTES);
-		return await (0, _noble_ciphers_webcrypto_js.gcm)(encryptionKey, encryptedMessage.slice(encryptedMessage.length - require_constants.IV_LEN_BYTES), 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)(require_constants.AES_KEY_BYTE_LENGTH);
-}
-
-//#endregion
-Object.defineProperty(exports, 'decryptSymmetrically', {
-  enumerable: true,
-  get: function () {
-    return decryptSymmetrically;
-  }
-});
-Object.defineProperty(exports, 'encryptSymmetrically', {
-  enumerable: true,
-  get: function () {
-    return encryptSymmetrically;
-  }
-});
-Object.defineProperty(exports, 'genSymmetricKey', {
-  enumerable: true,
-  get: function () {
-    return genSymmetricKey;
-  }
-});
-//# sourceMappingURL=aes-CuW_SPl-.js.map

package/dist/aes-CuW_SPl-.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"aes-CuW_SPl-.js","names":["IV_LEN_BYTES","AES_KEY_BYTE_LENGTH"],"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,6CAAiBA,+BAAa;AAEpC,iDADmB,2CAAiB,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,SAASA,+BAAa;AAGpF,SADe,2CAAiB,eADrB,iBAAiB,MAAM,iBAAiB,SAASA,+BAAa,EACtB,IAAI,CAAC,QAAQ,WAAW;UAEpE,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASxE,SAAgB,kBAA8B;AAC5C,gDAAmBC,sCAAoB"}

package/dist/chunk-DQk6qfdC.mjs

@@ -1,18 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-
-//#endregion
-export { __exportAll as t };

package/dist/chunk-EbLFQX5m.js

@@ -1,60 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-
-Object.defineProperty(exports, '__commonJSMin', {
-  enumerable: true,
-  get: function () {
-    return __commonJSMin;
-  }
-});
-Object.defineProperty(exports, '__exportAll', {
-  enumerable: true,
-  get: function () {
-    return __exportAll;
-  }
-});
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});