internxt-crypto 0.0.9-alpha → 0.0.11

package/README.md

@@ -73,7 +73,6 @@ import {
   keystoreService,
   deriveKey,
   hash,
-  SymmetricCiphertext
 } from 'internxt-crypto';
 
 // Asymmetric encryption
@@ -87,7 +86,7 @@ expect(resultAlice).toStrictEqual(resultBob);
 const data = utils.UTF8ToUint8('Sensitive information to encrypt'); // convert to Uint8Array 
 const additionalData = 'Additional non-secret data';
 const key = await symmetric.genSymmetricCryptoKey(); // CryptoKey 
-const ciphertext: SymmetricCiphertext = await symmetric.encryptSymmetrically(key, data, additionalData);
+const ciphertext: Uint8Array = await symmetric.encryptSymmetrically(key, data, additionalData);
 const plainText = await symmetric.decryptSymmetrically(encryptionKey, ciphertext, additionalData);
 expect(data).toStrictEqual(plainText);
 
@@ -143,11 +142,11 @@ const emailParams: EmailPublicParameters = {
   subject: 'email subject',
   sender: userAlice,
   recipient: userBob,
-  replyToEmailID: 2,
+  replyToEmailID: generateUuid(),
 };
 
 const email: Email = {
-  id: 'email id',
+  id:  generateUuid(),
   params: emailParams,
   body: emailBody,
 };

package/dist/asymmetric-crypto-BORmLhnx.js

@@ -0,0 +1,143 @@
+const require_chunk = require('./chunk-Dt-PWiN7.js');
+const require_constants = require('./constants-Ccp21E03.js');
+
+//#region src/asymmetric-crypto/ellipticCurve.ts
+/**
+* Derives secret key from the other user's public key and own private key
+*
+* @param otherUserPublicKey - The public key of the other user
+* @param ownPrivateKey - The private key
+* @returns The derived secret key bits
+*/
+async function deriveSecretKey(otherUserPublicKey, ownPrivateKey) {
+	try {
+		const result = await crypto.subtle.deriveBits({
+			name: require_constants.ECC_ALGORITHM,
+			public: otherUserPublicKey
+		}, ownPrivateKey, require_constants.AES_KEY_BIT_LENGTH);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to derive elliptic curve secret key", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/asymmetric-crypto/keys.ts
+/**
+* Generates elliptic curve key pair
+*
+* @returns The generated key pair
+*/
+async function generateEccKeys() {
+	try {
+		return await crypto.subtle.generateKey({ name: require_constants.ECC_ALGORITHM }, true, ["deriveBits"]);
+	} catch (error) {
+		throw new Error("Failed to generate elliptic curve key pair", { cause: error });
+	}
+}
+/**
+* Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)
+*
+* @returns The Uint8Array representation of the public key
+*/
+async function exportPublicKey(key) {
+	try {
+		const result = await crypto.subtle.exportKey("spki", key);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to export public key", { cause: error });
+	}
+}
+/**
+* Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey
+*
+* @returns The CryptoKey representation of the public key
+*/
+async function importPublicKey(spkiKeyData) {
+	try {
+		return await crypto.subtle.importKey("spki", spkiKeyData, { name: require_constants.ECC_ALGORITHM }, true, []);
+	} catch (error) {
+		throw new Error("Failed to import public key", { cause: error });
+	}
+}
+/**
+* Converts private key in CryptoKey to PKCS #8 format (RFC 5208)
+*
+* @returns The Uint8Array representation of the private key
+*/
+async function exportPrivateKey(key) {
+	try {
+		const result = await crypto.subtle.exportKey("pkcs8", key);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to export private key", { cause: error });
+	}
+}
+/**
+* Converts private key in PKCS #8 format (RFC 5208) to CryptoKey
+*
+* @returns The CryptoKey representation of the private key
+*/
+async function importPrivateKey(pkcs8KeyData) {
+	try {
+		return await crypto.subtle.importKey("pkcs8", pkcs8KeyData, { name: require_constants.ECC_ALGORITHM }, true, ["deriveBits"]);
+	} catch (error) {
+		throw new Error("Failed to import private key", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/asymmetric-crypto/index.ts
+var asymmetric_crypto_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	deriveSecretKey: () => deriveSecretKey,
+	exportPrivateKey: () => exportPrivateKey,
+	exportPublicKey: () => exportPublicKey,
+	generateEccKeys: () => generateEccKeys,
+	importPrivateKey: () => importPrivateKey,
+	importPublicKey: () => importPublicKey
+});
+
+//#endregion
+Object.defineProperty(exports, 'asymmetric_crypto_exports', {
+  enumerable: true,
+  get: function () {
+    return asymmetric_crypto_exports;
+  }
+});
+Object.defineProperty(exports, 'deriveSecretKey', {
+  enumerable: true,
+  get: function () {
+    return deriveSecretKey;
+  }
+});
+Object.defineProperty(exports, 'exportPrivateKey', {
+  enumerable: true,
+  get: function () {
+    return exportPrivateKey;
+  }
+});
+Object.defineProperty(exports, 'exportPublicKey', {
+  enumerable: true,
+  get: function () {
+    return exportPublicKey;
+  }
+});
+Object.defineProperty(exports, 'generateEccKeys', {
+  enumerable: true,
+  get: function () {
+    return generateEccKeys;
+  }
+});
+Object.defineProperty(exports, 'importPrivateKey', {
+  enumerable: true,
+  get: function () {
+    return importPrivateKey;
+  }
+});
+Object.defineProperty(exports, 'importPublicKey', {
+  enumerable: true,
+  get: function () {
+    return importPublicKey;
+  }
+});
+//# sourceMappingURL=asymmetric-crypto-BORmLhnx.js.map

package/dist/asymmetric-crypto-BORmLhnx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asymmetric-crypto-BORmLhnx.js","names":["ECC_ALGORITHM","AES_KEY_BIT_LENGTH","ECC_ALGORITHM"],"sources":["../src/asymmetric-crypto/ellipticCurve.ts","../src/asymmetric-crypto/keys.ts","../src/asymmetric-crypto/index.ts"],"sourcesContent":["import { ECC_ALGORITHM, AES_KEY_BIT_LENGTH } from '../constants';\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param otherUserPublicKey - The public key of the other user\n * @param ownPrivateKey - The private key\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(otherUserPublicKey: CryptoKey, ownPrivateKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.deriveBits(\n      {\n        name: ECC_ALGORITHM,\n        public: otherUserPublicKey,\n      },\n      ownPrivateKey,\n      AES_KEY_BIT_LENGTH,\n    );\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n","import { ECC_ALGORITHM } from '../constants';\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<CryptoKeyPair> {\n  try {\n    return (await crypto.subtle.generateKey(\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    )) as CryptoKeyPair;\n  } catch (error) {\n    throw new Error('Failed to generate elliptic curve key pair', { cause: error });\n  }\n}\n\n/**\n * Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)\n *\n * @returns The Uint8Array representation of the public key\n */\nexport async function exportPublicKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('spki', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export public key', { cause: error });\n  }\n}\n\n/**\n * Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey\n *\n * @returns The CryptoKey representation of the public key\n */\nexport async function importPublicKey(spkiKeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'spki',\n      spkiKeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      [],\n    );\n  } catch (error) {\n    throw new Error('Failed to import public key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in CryptoKey to PKCS #8 format (RFC 5208)\n *\n * @returns The Uint8Array representation of the private key\n */\nexport async function exportPrivateKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('pkcs8', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export private key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in PKCS #8 format (RFC 5208) to CryptoKey\n *\n * @returns The CryptoKey representation of the private key\n */\nexport async function importPrivateKey(pkcs8KeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'pkcs8',\n      pkcs8KeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    );\n  } catch (error) {\n    throw new Error('Failed to import private key', { cause: error });\n  }\n}\n","export * from './ellipticCurve';\nexport * from './keys';\n"],"mappings":";;;;;;;;;;;AASA,eAAsB,gBAAgB,oBAA+B,eAA+C;AAClH,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,WACjC;GACE,MAAMA;GACN,QAAQ;GACT,EACD,eACAC,qCACD;AACD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACdnF,eAAsB,kBAA0C;AAC9D,KAAI;AACF,SAAQ,MAAM,OAAO,OAAO,YAC1B,EACE,MAAMC,iCACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,gBAAgB,KAAqC;AACzE,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,QAAQ,IAAI;AACzD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,gBAAgB,aAA6C;AACjF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,QACA,aACA,EACE,MAAMA,iCACP,EACD,MACA,EAAE,CACH;UACM,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,iBAAiB,KAAqC;AAC1E,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,SAAS,IAAI;AAC1D,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASrE,eAAsB,iBAAiB,cAA8C;AACnF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,SACA,cACA,EACE,MAAMA,iCACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC"}

package/dist/asymmetric-crypto-CyXsV4XT.mjs

@@ -0,0 +1,102 @@
+import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
+import { g as ECC_ALGORITHM, n as AES_KEY_BIT_LENGTH } from "./constants-kTeX-2T0.mjs";
+
+//#region src/asymmetric-crypto/ellipticCurve.ts
+/**
+* Derives secret key from the other user's public key and own private key
+*
+* @param otherUserPublicKey - The public key of the other user
+* @param ownPrivateKey - The private key
+* @returns The derived secret key bits
+*/
+async function deriveSecretKey(otherUserPublicKey, ownPrivateKey) {
+	try {
+		const result = await crypto.subtle.deriveBits({
+			name: ECC_ALGORITHM,
+			public: otherUserPublicKey
+		}, ownPrivateKey, AES_KEY_BIT_LENGTH);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to derive elliptic curve secret key", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/asymmetric-crypto/keys.ts
+/**
+* Generates elliptic curve key pair
+*
+* @returns The generated key pair
+*/
+async function generateEccKeys() {
+	try {
+		return await crypto.subtle.generateKey({ name: ECC_ALGORITHM }, true, ["deriveBits"]);
+	} catch (error) {
+		throw new Error("Failed to generate elliptic curve key pair", { cause: error });
+	}
+}
+/**
+* Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)
+*
+* @returns The Uint8Array representation of the public key
+*/
+async function exportPublicKey(key) {
+	try {
+		const result = await crypto.subtle.exportKey("spki", key);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to export public key", { cause: error });
+	}
+}
+/**
+* Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey
+*
+* @returns The CryptoKey representation of the public key
+*/
+async function importPublicKey(spkiKeyData) {
+	try {
+		return await crypto.subtle.importKey("spki", spkiKeyData, { name: ECC_ALGORITHM }, true, []);
+	} catch (error) {
+		throw new Error("Failed to import public key", { cause: error });
+	}
+}
+/**
+* Converts private key in CryptoKey to PKCS #8 format (RFC 5208)
+*
+* @returns The Uint8Array representation of the private key
+*/
+async function exportPrivateKey(key) {
+	try {
+		const result = await crypto.subtle.exportKey("pkcs8", key);
+		return new Uint8Array(result);
+	} catch (error) {
+		throw new Error("Failed to export private key", { cause: error });
+	}
+}
+/**
+* Converts private key in PKCS #8 format (RFC 5208) to CryptoKey
+*
+* @returns The CryptoKey representation of the private key
+*/
+async function importPrivateKey(pkcs8KeyData) {
+	try {
+		return await crypto.subtle.importKey("pkcs8", pkcs8KeyData, { name: ECC_ALGORITHM }, true, ["deriveBits"]);
+	} catch (error) {
+		throw new Error("Failed to import private key", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/asymmetric-crypto/index.ts
+var asymmetric_crypto_exports = /* @__PURE__ */ __exportAll({
+	deriveSecretKey: () => deriveSecretKey,
+	exportPrivateKey: () => exportPrivateKey,
+	exportPublicKey: () => exportPublicKey,
+	generateEccKeys: () => generateEccKeys,
+	importPrivateKey: () => importPrivateKey,
+	importPublicKey: () => importPublicKey
+});
+
+//#endregion
+export { importPrivateKey as a, generateEccKeys as i, exportPrivateKey as n, importPublicKey as o, exportPublicKey as r, deriveSecretKey as s, asymmetric_crypto_exports as t };
+//# sourceMappingURL=asymmetric-crypto-CyXsV4XT.mjs.map

package/dist/asymmetric-crypto-CyXsV4XT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"asymmetric-crypto-CyXsV4XT.mjs","names":[],"sources":["../src/asymmetric-crypto/ellipticCurve.ts","../src/asymmetric-crypto/keys.ts","../src/asymmetric-crypto/index.ts"],"sourcesContent":["import { ECC_ALGORITHM, AES_KEY_BIT_LENGTH } from '../constants';\n\n/**\n * Derives secret key from the other user's public key and own private key\n *\n * @param otherUserPublicKey - The public key of the other user\n * @param ownPrivateKey - The private key\n * @returns The derived secret key bits\n */\nexport async function deriveSecretKey(otherUserPublicKey: CryptoKey, ownPrivateKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.deriveBits(\n      {\n        name: ECC_ALGORITHM,\n        public: otherUserPublicKey,\n      },\n      ownPrivateKey,\n      AES_KEY_BIT_LENGTH,\n    );\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to derive elliptic curve secret key', { cause: error });\n  }\n}\n","import { ECC_ALGORITHM } from '../constants';\n\n/**\n * Generates elliptic curve key pair\n *\n * @returns The generated key pair\n */\nexport async function generateEccKeys(): Promise<CryptoKeyPair> {\n  try {\n    return (await crypto.subtle.generateKey(\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    )) as CryptoKeyPair;\n  } catch (error) {\n    throw new Error('Failed to generate elliptic curve key pair', { cause: error });\n  }\n}\n\n/**\n * Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)\n *\n * @returns The Uint8Array representation of the public key\n */\nexport async function exportPublicKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('spki', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export public key', { cause: error });\n  }\n}\n\n/**\n * Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey\n *\n * @returns The CryptoKey representation of the public key\n */\nexport async function importPublicKey(spkiKeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'spki',\n      spkiKeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      [],\n    );\n  } catch (error) {\n    throw new Error('Failed to import public key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in CryptoKey to PKCS #8 format (RFC 5208)\n *\n * @returns The Uint8Array representation of the private key\n */\nexport async function exportPrivateKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.exportKey('pkcs8', key);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to export private key', { cause: error });\n  }\n}\n\n/**\n * Converts private key in PKCS #8 format (RFC 5208) to CryptoKey\n *\n * @returns The CryptoKey representation of the private key\n */\nexport async function importPrivateKey(pkcs8KeyData: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(\n      'pkcs8',\n      pkcs8KeyData as BufferSource,\n      {\n        name: ECC_ALGORITHM,\n      },\n      true,\n      ['deriveBits'],\n    );\n  } catch (error) {\n    throw new Error('Failed to import private key', { cause: error });\n  }\n}\n","export * from './ellipticCurve';\nexport * from './keys';\n"],"mappings":";;;;;;;;;;;AASA,eAAsB,gBAAgB,oBAA+B,eAA+C;AAClH,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,WACjC;GACE,MAAM;GACN,QAAQ;GACT,EACD,eACA,mBACD;AACD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;ACdnF,eAAsB,kBAA0C;AAC9D,KAAI;AACF,SAAQ,MAAM,OAAO,OAAO,YAC1B,EACE,MAAM,eACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,8CAA8C,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASnF,eAAsB,gBAAgB,KAAqC;AACzE,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,QAAQ,IAAI;AACzD,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,gBAAgB,aAA6C;AACjF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,QACA,aACA,EACE,MAAM,eACP,EACD,MACA,EAAE,CACH;UACM,OAAO;AACd,QAAM,IAAI,MAAM,+BAA+B,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASpE,eAAsB,iBAAiB,KAAqC;AAC1E,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,SAAS,IAAI;AAC1D,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AASrE,eAAsB,iBAAiB,cAA8C;AACnF,KAAI;AACF,SAAO,MAAM,OAAO,OAAO,UACzB,SACA,cACA,EACE,MAAM,eACP,EACD,MACA,CAAC,aAAa,CACf;UACM,OAAO;AACd,QAAM,IAAI,MAAM,gCAAgC,EAAE,OAAO,OAAO,CAAC"}

package/dist/asymmetric-crypto.d.mts

@@ -0,0 +1,47 @@
+//#region src/asymmetric-crypto/ellipticCurve.d.ts
+/**
+ * Derives secret key from the other user's public key and own private key
+ *
+ * @param otherUserPublicKey - The public key of the other user
+ * @param ownPrivateKey - The private key
+ * @returns The derived secret key bits
+ */
+declare function deriveSecretKey(otherUserPublicKey: CryptoKey, ownPrivateKey: CryptoKey): Promise<Uint8Array>;
+//#endregion
+//#region src/asymmetric-crypto/keys.d.ts
+/**
+ * Generates elliptic curve key pair
+ *
+ * @returns The generated key pair
+ */
+declare function generateEccKeys(): Promise<CryptoKeyPair>;
+/**
+ * Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)
+ *
+ * @returns The Uint8Array representation of the public key
+ */
+declare function exportPublicKey(key: CryptoKey): Promise<Uint8Array>;
+/**
+ * Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey
+ *
+ * @returns The CryptoKey representation of the public key
+ */
+declare function importPublicKey(spkiKeyData: Uint8Array): Promise<CryptoKey>;
+/**
+ * Converts private key in CryptoKey to PKCS #8 format (RFC 5208)
+ *
+ * @returns The Uint8Array representation of the private key
+ */
+declare function exportPrivateKey(key: CryptoKey): Promise<Uint8Array>;
+/**
+ * Converts private key in PKCS #8 format (RFC 5208) to CryptoKey
+ *
+ * @returns The CryptoKey representation of the private key
+ */
+declare function importPrivateKey(pkcs8KeyData: Uint8Array): Promise<CryptoKey>;
+declare namespace index_d_exports {
+  export { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey };
+}
+//#endregion
+export { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey, index_d_exports as t };
+//# sourceMappingURL=asymmetric-crypto.d.mts.map

package/dist/asymmetric-crypto.d.ts

@@ -0,0 +1,47 @@
+//#region src/asymmetric-crypto/ellipticCurve.d.ts
+/**
+ * Derives secret key from the other user's public key and own private key
+ *
+ * @param otherUserPublicKey - The public key of the other user
+ * @param ownPrivateKey - The private key
+ * @returns The derived secret key bits
+ */
+declare function deriveSecretKey(otherUserPublicKey: CryptoKey, ownPrivateKey: CryptoKey): Promise<Uint8Array>;
+//#endregion
+//#region src/asymmetric-crypto/keys.d.ts
+/**
+ * Generates elliptic curve key pair
+ *
+ * @returns The generated key pair
+ */
+declare function generateEccKeys(): Promise<CryptoKeyPair>;
+/**
+ * Converts public CryptoKey into Uint8Array using SubjectPublicKeyInfo format (RFC 5280)
+ *
+ * @returns The Uint8Array representation of the public key
+ */
+declare function exportPublicKey(key: CryptoKey): Promise<Uint8Array>;
+/**
+ * Converts public key in SubjectPublicKeyInfo format (RFC 5280) to CryptoKey
+ *
+ * @returns The CryptoKey representation of the public key
+ */
+declare function importPublicKey(spkiKeyData: Uint8Array): Promise<CryptoKey>;
+/**
+ * Converts private key in CryptoKey to PKCS #8 format (RFC 5208)
+ *
+ * @returns The Uint8Array representation of the private key
+ */
+declare function exportPrivateKey(key: CryptoKey): Promise<Uint8Array>;
+/**
+ * Converts private key in PKCS #8 format (RFC 5208) to CryptoKey
+ *
+ * @returns The CryptoKey representation of the private key
+ */
+declare function importPrivateKey(pkcs8KeyData: Uint8Array): Promise<CryptoKey>;
+declare namespace index_d_exports {
+  export { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey };
+}
+//#endregion
+export { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey, index_d_exports as t };
+//# sourceMappingURL=asymmetric-crypto.d.ts.map

package/dist/asymmetric-crypto.js

@@ -0,0 +1,8 @@
+const require_asymmetric_crypto = require('./asymmetric-crypto-BORmLhnx.js');
+
+exports.deriveSecretKey = require_asymmetric_crypto.deriveSecretKey;
+exports.exportPrivateKey = require_asymmetric_crypto.exportPrivateKey;
+exports.exportPublicKey = require_asymmetric_crypto.exportPublicKey;
+exports.generateEccKeys = require_asymmetric_crypto.generateEccKeys;
+exports.importPrivateKey = require_asymmetric_crypto.importPrivateKey;
+exports.importPublicKey = require_asymmetric_crypto.importPublicKey;

package/dist/asymmetric-crypto.mjs

@@ -0,0 +1,3 @@
+import { a as importPrivateKey, i as generateEccKeys, n as exportPrivateKey, o as importPublicKey, r as exportPublicKey, s as deriveSecretKey } from "./asymmetric-crypto-CyXsV4XT.mjs";
+
+export { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey };

package/dist/chunk-DWirmd9C.mjs

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

package/dist/chunk-Dt-PWiN7.js

@@ -0,0 +1,60 @@
+//#region rolldown:runtime
+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, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (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;
+  }
+});