internxt-crypto 0.0.11 → 0.0.14

package/dist/types.d.mts

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

package/dist/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,aAAA,EAAe,kBAAA;AAAA;AAAA,KAGL,IAAA;EACV,KAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA,GAAqB,IAAA;EAC/B,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,UAAA;EACV,YAAA,EAAc,SAAA;EACd,cAAA,EAAgB,UAAA;AAAA;AAAA,KAGN,gBAAA;EACV,kBAAA;EACA,oBAAA;AAAA;AAAA,KAGU,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,WAAA;EACV,aAAA,EAAe,SAAA;EACf,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,oBAAA;EACV,mBAAA;EACA,qBAAA;AAAA;AAAA,KAGU,SAAA;EACV,UAAA,EAAY,UAAA;EACZ,WAAA,EAAa,WAAA;AAAA;AAAA,KAGH,kBAAA;EACV,UAAA,EAAY,gBAAA;EACZ,WAAA,EAAa,oBAAA;AAAA;AAAA,KAGH,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,GAAA,EAAK,kBAAA;EACL,cAAA;EACA,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,GAAA,EAAK,kBAAA;EACL,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,WAAA;EACV,MAAA,EAAQ,qBAAA;EACR,GAAA,EAAK,kBAAA;EACL,EAAA;AAAA;AAAA,KAGU,YAAA;EACV,eAAA;EACA,YAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,WAAA;AAAA;AAAA,KAGU,qBAAA;EACV,OAAA;EACA,SAAA;EACA,MAAA,EAAQ,IAAA;EACR,SAAA,EAAW,IAAA;EACX,UAAA,GAAa,IAAA;EACb,cAAA;EACA,MAAA;AAAA;AAAA,KAGU,KAAA;EACV,EAAA;EACA,IAAA,EAAM,SAAA;EACN,MAAA,EAAQ,qBAAA;AAAA;AAAA,UAGO,SAAA;EACf,OAAA,EAAS,GAAA,SAAY,KAAA;EACrB,SAAA;EACA,cAAA;EACA,YAAA;AAAA;AAAA,UAEe,iBAAA;EACf,KAAA,EAAO,KAAA;EACP,KAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}

package/dist/types.d.ts

@@ -1,2 +1,108 @@
-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 };
+//#region src/types.d.ts
+type EncryptedKeystore = {
+  userEmail: string;
+  type: KeystoreType;
+  encryptedKeys: EmailKeysEncrypted;
+};
+type User = {
+  email: string;
+  name: string;
+};
+type UserWithPublicKeys = User & {
+  publicKeys: PublicKeys;
+};
+type PublicKeys = {
+  eccPublicKey: CryptoKey;
+  kyberPublicKey: Uint8Array;
+};
+type PublicKeysBase64 = {
+  eccPublicKeyBase64: string;
+  kyberPublicKeyBase64: string;
+};
+type HybridKeyPair = {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
+type PrivateKeys = {
+  eccPrivateKey: CryptoKey;
+  kyberPrivateKey: Uint8Array;
+};
+type PrivateKeysEncrypted = {
+  eccPrivateKeyBase64: string;
+  kyberPrivateKeyBase64: string;
+};
+type EmailKeys = {
+  publicKeys: PublicKeys;
+  privateKeys: PrivateKeys;
+};
+type EmailKeysEncrypted = {
+  publicKeys: PublicKeysBase64;
+  privateKeys: PrivateKeysEncrypted;
+};
+type HybridEncryptedEmail = {
+  encryptedKey: HybridEncKey;
+  enc: EmailBodyEncrypted;
+  recipientEmail: string;
+  params: EmailPublicParameters;
+  id: string;
+  isSubjectEncrypted: boolean;
+};
+type PwdProtectedEmail = {
+  encryptedKey: PwdProtectedKey;
+  enc: EmailBodyEncrypted;
+  params: EmailPublicParameters;
+  id: string;
+  isSubjectEncrypted: boolean;
+};
+type StoredEmail = {
+  params: EmailPublicParameters;
+  enc: EmailBodyEncrypted;
+  id: string;
+};
+type HybridEncKey = {
+  kyberCiphertext: string;
+  encryptedKey: string;
+};
+type PwdProtectedKey = {
+  encryptedKey: string;
+  salt: string;
+};
+type EmailBodyEncrypted = {
+  encText: string;
+  encAttachments?: string[];
+};
+type EmailBody = {
+  text: string;
+  attachments?: string[];
+};
+type EmailPublicParameters = {
+  subject: string;
+  createdAt: string;
+  sender: User;
+  recipient: User;
+  recipients?: User[];
+  replyToEmailID?: string;
+  labels?: string[];
+};
+type Email = {
+  id: string;
+  body: EmailBody;
+  params: EmailPublicParameters;
+};
+interface MailCache<Email> {
+  esCache: Map<string, Email>;
+  cacheSize: number;
+  isCacheLimited: boolean;
+  isCacheReady: boolean;
+}
+interface EmailSearchResult {
+  email: Email;
+  score?: number;
+}
+declare enum KeystoreType {
+  ENCRYPTION = "Encryption",
+  RECOVERY = "Recovery"
+}
+//#endregion
+export { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,aAAA,EAAe,kBAAA;AAAA;AAAA,KAGL,IAAA;EACV,KAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA,GAAqB,IAAA;EAC/B,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,UAAA;EACV,YAAA,EAAc,SAAA;EACd,cAAA,EAAgB,UAAA;AAAA;AAAA,KAGN,gBAAA;EACV,kBAAA;EACA,oBAAA;AAAA;AAAA,KAGU,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,WAAA;EACV,aAAA,EAAe,SAAA;EACf,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,oBAAA;EACV,mBAAA;EACA,qBAAA;AAAA;AAAA,KAGU,SAAA;EACV,UAAA,EAAY,UAAA;EACZ,WAAA,EAAa,WAAA;AAAA;AAAA,KAGH,kBAAA;EACV,UAAA,EAAY,gBAAA;EACZ,WAAA,EAAa,oBAAA;AAAA;AAAA,KAGH,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,GAAA,EAAK,kBAAA;EACL,cAAA;EACA,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,GAAA,EAAK,kBAAA;EACL,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,WAAA;EACV,MAAA,EAAQ,qBAAA;EACR,GAAA,EAAK,kBAAA;EACL,EAAA;AAAA;AAAA,KAGU,YAAA;EACV,eAAA;EACA,YAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,WAAA;AAAA;AAAA,KAGU,qBAAA;EACV,OAAA;EACA,SAAA;EACA,MAAA,EAAQ,IAAA;EACR,SAAA,EAAW,IAAA;EACX,UAAA,GAAa,IAAA;EACb,cAAA;EACA,MAAA;AAAA;AAAA,KAGU,KAAA;EACV,EAAA;EACA,IAAA,EAAM,SAAA;EACN,MAAA,EAAQ,qBAAA;AAAA;AAAA,UAGO,SAAA;EACf,OAAA,EAAS,GAAA,SAAY,KAAA;EACrB,SAAA;EACA,cAAA;EACA,YAAA;AAAA;AAAA,UAEe,iBAAA;EACf,KAAA,EAAO,KAAA;EACP,KAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}

package/dist/types.js

@@ -1,3 +1,12 @@
-const require_types = require('./types-52g887Zi.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-exports.KeystoreType = require_types.KeystoreType;
+//#region src/types.ts
+let KeystoreType = /* @__PURE__ */ function(KeystoreType) {
+	KeystoreType["ENCRYPTION"] = "Encryption";
+	KeystoreType["RECOVERY"] = "Recovery";
+	return KeystoreType;
+}({});
+
+//#endregion
+exports.KeystoreType = KeystoreType;
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

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

package/dist/types.mjs

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

package/dist/types.mjs.map

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

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { g as PublicKeysBase64, h as PublicKeys } from "./types-DwQJtrTx.mjs";
+import { PublicKeys, PublicKeysBase64 } from "./types.mjs";
 
 //#region src/utils/converters.d.ts
 /**
@@ -91,9 +91,6 @@ declare function bytesToMnemonic(bytes: Uint8Array): string;
 declare function generateUuid(): string;
 declare function uuidToBytes(uuid: string): Uint8Array;
 declare function bytesToUuid(bytes: Uint8Array): string;
-declare namespace index_d_exports {
-  export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
-}
 //#endregion
-export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, index_d_exports as t, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
+export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
 //# sourceMappingURL=utils.d.mts.map

package/dist/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils/converters.ts","../src/utils/keyConverters.ts","../src/utils/genMnemonic.ts","../src/utils/genID.ts"],"mappings":";;;;;;AAQA;;;iBAAgB,eAAA,CAAgB,KAAA,EAAO,UAAA;;AAUvC;;;;;iBAAgB,WAAA,CAAY,GAAA,WAAc,UAAA;;;;;AAoB1C;;iBAVgB,WAAA,CAAY,KAAA,EAAO,UAAA;;;AAoBnC;;;;iBAVgB,eAAA,CAAgB,GAAA,WAAc,UAAA;AAsB9C;;;;;;AAAA,iBAZgB,kBAAA,CAAmB,MAAA,EAAQ,UAAA;;ACtC3C;;;;;iBDkDgB,kBAAA,CAAmB,GAAA,WAAc,UAAA;;;;;AApDjD;;;;iBCEsB,iBAAA,CAAkB,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,UAAA;ADQ3E;;;;;AAUA;AAVA,iBCYsB,iBAAA,CAAkB,GAAA,EAAK,UAAA,GAAa,OAAA,CAAQ,gBAAA;;;;;;ADtBlE;;iBEAgB,WAAA,CAAA;;;AFUhB;;;;iBEAgB,eAAA,CAAgB,QAAA,WAAmB,UAAA;AFUnD;;;;;AAUA;AAVA,iBEAgB,eAAA,CAAgB,KAAA,EAAO,UAAA;;;;;;AFpBvC;;iBGFgB,YAAA,CAAA;AAAA,iBAIA,WAAA,CAAY,IAAA,WAAe,UAAA;AAAA,iBAI3B,WAAA,CAAY,KAAA,EAAO,UAAA"}

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { g as PublicKeysBase64, h as PublicKeys } from "./types-Ds3ivE9W.js";
+import { PublicKeys, PublicKeysBase64 } from "./types.js";
 
 //#region src/utils/converters.d.ts
 /**
@@ -91,9 +91,6 @@ declare function bytesToMnemonic(bytes: Uint8Array): string;
 declare function generateUuid(): string;
 declare function uuidToBytes(uuid: string): Uint8Array;
 declare function bytesToUuid(bytes: Uint8Array): string;
-declare namespace index_d_exports {
-  export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
-}
 //#endregion
-export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, index_d_exports as t, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
+export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../src/utils/converters.ts","../src/utils/keyConverters.ts","../src/utils/genMnemonic.ts","../src/utils/genID.ts"],"mappings":";;;;;;AAQA;;;iBAAgB,eAAA,CAAgB,KAAA,EAAO,UAAA;;AAUvC;;;;;iBAAgB,WAAA,CAAY,GAAA,WAAc,UAAA;;;;;AAoB1C;;iBAVgB,WAAA,CAAY,KAAA,EAAO,UAAA;;;AAoBnC;;;;iBAVgB,eAAA,CAAgB,GAAA,WAAc,UAAA;AAsB9C;;;;;;AAAA,iBAZgB,kBAAA,CAAmB,MAAA,EAAQ,UAAA;;ACtC3C;;;;;iBDkDgB,kBAAA,CAAmB,GAAA,WAAc,UAAA;;;;;AApDjD;;;;iBCEsB,iBAAA,CAAkB,MAAA,EAAQ,gBAAA,GAAmB,OAAA,CAAQ,UAAA;ADQ3E;;;;;AAUA;AAVA,iBCYsB,iBAAA,CAAkB,GAAA,EAAK,UAAA,GAAa,OAAA,CAAQ,gBAAA;;;;;;ADtBlE;;iBEAgB,WAAA,CAAA;;;AFUhB;;;;iBEAgB,eAAA,CAAgB,QAAA,WAAmB,UAAA;AFUnD;;;;;AAUA;AAVA,iBEAgB,eAAA,CAAgB,KAAA,EAAO,UAAA;;;;;;AFpBvC;;iBGFgB,YAAA,CAAA;AAAA,iBAIA,WAAA,CAAY,IAAA,WAAe,UAAA;AAAA,iBAI3B,WAAA,CAAY,KAAA,EAAO,UAAA"}

package/dist/utils.js

@@ -1,16 +1,17 @@
-const require_utils = require('./utils-CNs3cyDj.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_genID = require('./genID-YJSl3YhL.js');
 
-exports.UTF8ToUint8 = require_utils.UTF8ToUint8;
-exports.base64ToPublicKey = require_utils.base64ToPublicKey;
-exports.base64ToUint8Array = require_utils.base64ToUint8Array;
-exports.bytesToMnemonic = require_utils.bytesToMnemonic;
-exports.bytesToUuid = require_utils.bytesToUuid;
-exports.genMnemonic = require_utils.genMnemonic;
-exports.generateUuid = require_utils.generateUuid;
-exports.hexToUint8Array = require_utils.hexToUint8Array;
-exports.mnemonicToBytes = require_utils.mnemonicToBytes;
-exports.publicKeyToBase64 = require_utils.publicKeyToBase64;
-exports.uint8ArrayToBase64 = require_utils.uint8ArrayToBase64;
-exports.uint8ArrayToHex = require_utils.uint8ArrayToHex;
-exports.uint8ToUTF8 = require_utils.uint8ToUTF8;
-exports.uuidToBytes = require_utils.uuidToBytes;
+exports.UTF8ToUint8 = require_genID.UTF8ToUint8;
+exports.base64ToPublicKey = require_genID.base64ToPublicKey;
+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.publicKeyToBase64 = require_genID.publicKeyToBase64;
+exports.uint8ArrayToBase64 = require_genID.uint8ArrayToBase64;
+exports.uint8ArrayToHex = require_genID.uint8ArrayToHex;
+exports.uint8ToUTF8 = require_genID.uint8ToUTF8;
+exports.uuidToBytes = require_genID.uuidToBytes;

package/dist/utils.mjs

@@ -1,3 +1,3 @@
-import { a as bytesToMnemonic, c as base64ToPublicKey, d as base64ToUint8Array, f as hexToUint8Array, h as uint8ToUTF8, i as uuidToBytes, l as publicKeyToBase64, m as uint8ArrayToHex, n as bytesToUuid, o as genMnemonic, p as uint8ArrayToBase64, r as generateUuid, s as mnemonicToBytes, u as UTF8ToUint8 } from "./utils-DS04iUcX.mjs";
+import { a as genMnemonic, c as publicKeyToBase64, d as hexToUint8Array, f as uint8ArrayToBase64, i as bytesToMnemonic, l as UTF8ToUint8, m as uint8ToUTF8, n as generateUuid, o as mnemonicToBytes, p as uint8ArrayToHex, r as uuidToBytes, s as base64ToPublicKey, t as bytesToUuid, u as base64ToUint8Array } from "./genID-3Er5IowC.mjs";
 
 export { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "internxt-crypto",
-  "version": "0.0.11",
+  "version": "0.0.14",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
@@ -9,46 +9,56 @@
   ],
   "scripts": {
     "prepare": "husky",
-    "dev": "vite",
     "build": "tsdown",
-    "start": "vite preview",
-    "build:staging": "vite build --mode staging",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "format": "prettier \"{src,tests}/**/*.{ts,tsx}\" --write",
     "lint:ts": "eslint \"./{src,tests}/**/*.{ts,tsx}\"",
-    "lint:fix": "yarn run lint:ts --fix"
+    "lint:fix": "yarn run lint:ts --fix",
+    "unused": "knip"
   },
   "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",
-    "@types/flexsearch": "^0.7.42",
-    "@vitest/browser": "^4.0.10",
+    "@playwright/test": "^1.54.2",
+    "@types/node": "^25.2.3",
     "@vitest/browser-playwright": "^4.0.10",
     "@vitest/coverage-istanbul": "^4.0.10",
-    "eslint": "^9.34.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^10.0.0",
+    "knip": "^5.84.0",
     "lint-staged": "^16.1.4",
     "playwright": "^1.54.1",
     "prettier": "^3.6.2",
-    "tsdown": "^0.20.0-beta.4",
+    "tsdown": "^0.20.1",
     "typescript": "^5.9.3",
-    "vite": "^7.0.6",
     "vitest": "^4.0.0"
   },
   "dependencies": {
-    "@emailjs/browser": "^4.4.1",
+    "@noble/ciphers": "^2.1.1",
     "@noble/hashes": "^2.0.1",
     "@noble/post-quantum": "^0.5.2",
     "@scure/bip39": "^2.0.1",
-    "axios": "^1.11.0",
     "flexsearch": "^0.8.205",
     "hash-wasm": "^4.12.0",
     "husky": "^9.1.7",
     "idb": "^8.0.3",
     "uuid": "^13.0.0"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.mjs",
+      "require": "./dist/*.js"
+    }
+  },
+  "sideEffects": false,
   "lint-staged": {
     "*.{js,jsx,tsx,ts}": [
       "prettier --write"

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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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"}