@oxyhq/services 5.16.23 → 5.16.25

package/lib/module/crypto/keyManager.js

@@ -0,0 +1,508 @@
+"use strict";
+
+/**
+ * Key Manager - ECDSA secp256k1 Key Generation and Storage
+ * 
+ * Handles secure generation, storage, and retrieval of cryptographic keys.
+ * Private keys are stored securely using expo-secure-store and never leave the device.
+ */
+
+import { ec as EC } from 'elliptic';
+import { Platform } from 'react-native';
+
+// Lazy imports for React Native specific modules
+let SecureStore = null;
+let ExpoCrypto = null;
+const ec = new EC('secp256k1');
+const STORAGE_KEYS = {
+  PRIVATE_KEY: 'oxy_identity_private_key',
+  PUBLIC_KEY: 'oxy_identity_public_key',
+  BACKUP_PRIVATE_KEY: 'oxy_identity_backup_private_key',
+  BACKUP_PUBLIC_KEY: 'oxy_identity_backup_public_key',
+  BACKUP_TIMESTAMP: 'oxy_identity_backup_timestamp'
+};
+
+/**
+ * Initialize React Native specific modules
+ * This allows the module to work in both Node.js and React Native environments
+ */
+async function initSecureStore() {
+  if (!SecureStore) {
+    try {
+      SecureStore = await import('expo-secure-store');
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load expo-secure-store: ${errorMessage}. Make sure expo-secure-store is installed and properly configured.`);
+    }
+  }
+  if (!SecureStore) {
+    throw new Error('expo-secure-store module is not available');
+  }
+  return SecureStore;
+}
+
+/**
+ * Check if we're in a React Native environment
+ */
+function isReactNative() {
+  return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+}
+
+/**
+ * Check if we're in a Node.js environment
+ */
+function isNodeJS() {
+  return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+}
+
+/**
+ * Check if we're on web platform
+ * Identity storage is only available on native platforms (iOS/Android)
+ */
+function isWebPlatform() {
+  try {
+    return Platform.OS === 'web';
+  } catch {
+    // Fallback if Platform is not available
+    return typeof window !== 'undefined' && typeof navigator !== 'undefined' && navigator.product !== 'ReactNative';
+  }
+}
+async function initExpoCrypto() {
+  if (!ExpoCrypto) {
+    ExpoCrypto = await import('expo-crypto');
+  }
+  return ExpoCrypto;
+}
+
+/**
+ * Convert Uint8Array to hexadecimal string
+ * Works in both Node.js and React Native
+ */
+function uint8ArrayToHex(bytes) {
+  return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
+/**
+ * Generate cryptographically secure random bytes
+ */
+async function getSecureRandomBytes(length) {
+  // In React Native, always use expo-crypto
+  if (isReactNative() || !isNodeJS()) {
+    const Crypto = await initExpoCrypto();
+    return Crypto.getRandomBytes(length);
+  }
+
+  // In Node.js, use Node's crypto module
+  // Use Function constructor to prevent Metro bundler from statically analyzing this require
+  // This ensures the require is only evaluated in Node.js runtime, not during Metro bundling
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    const getCrypto = new Function('return require("crypto")');
+    const crypto = getCrypto();
+    return new Uint8Array(crypto.randomBytes(length));
+  } catch (error) {
+    // Fallback to expo-crypto if Node crypto fails
+    const Crypto = await initExpoCrypto();
+    return Crypto.getRandomBytes(length);
+  }
+}
+export class KeyManager {
+  // In-memory cache for identity state (invalidated on identity changes)
+  static cachedPublicKey = null;
+  static cachedHasIdentity = null;
+
+  /**
+   * Invalidate cached identity state
+   * Called internally when identity is created/deleted/imported
+   */
+  static invalidateCache() {
+    KeyManager.cachedPublicKey = null;
+    KeyManager.cachedHasIdentity = null;
+  }
+
+  /**
+   * Generate a new ECDSA secp256k1 key pair
+   * Returns the keys in hexadecimal format
+   */
+  static generateKeyPairSync() {
+    const keyPair = ec.genKeyPair();
+    return {
+      privateKey: keyPair.getPrivate('hex'),
+      publicKey: keyPair.getPublic('hex')
+    };
+  }
+
+  /**
+   * Generate a new key pair using secure random bytes
+   */
+  static async generateKeyPair() {
+    const randomBytes = await getSecureRandomBytes(32);
+    const privateKeyHex = uint8ArrayToHex(randomBytes);
+    const keyPair = ec.keyFromPrivate(privateKeyHex);
+    return {
+      privateKey: keyPair.getPrivate('hex'),
+      publicKey: keyPair.getPublic('hex')
+    };
+  }
+
+  /**
+   * Generate and securely store a new key pair on the device
+   * Returns only the public key (private key is stored securely)
+   */
+  static async createIdentity() {
+    if (isWebPlatform()) {
+      throw new Error('Identity creation is only available on native platforms (iOS/Android). Please use the native app to create your identity.');
+    }
+    const store = await initSecureStore();
+    const {
+      privateKey,
+      publicKey
+    } = await KeyManager.generateKeyPair();
+    await store.setItemAsync(STORAGE_KEYS.PRIVATE_KEY, privateKey, {
+      keychainAccessible: store.WHEN_UNLOCKED_THIS_DEVICE_ONLY
+    });
+    await store.setItemAsync(STORAGE_KEYS.PUBLIC_KEY, publicKey);
+
+    // Update cache
+    KeyManager.cachedPublicKey = publicKey;
+    KeyManager.cachedHasIdentity = true;
+    return publicKey;
+  }
+
+  /**
+   * Import an existing key pair (e.g., from backup file)
+   */
+  static async importKeyPair(privateKey) {
+    if (isWebPlatform()) {
+      throw new Error('Identity import is only available on native platforms (iOS/Android). Please use the native app to import your identity.');
+    }
+    const store = await initSecureStore();
+    const keyPair = ec.keyFromPrivate(privateKey);
+    const publicKey = keyPair.getPublic('hex');
+    await store.setItemAsync(STORAGE_KEYS.PRIVATE_KEY, privateKey, {
+      keychainAccessible: store.WHEN_UNLOCKED_THIS_DEVICE_ONLY
+    });
+    await store.setItemAsync(STORAGE_KEYS.PUBLIC_KEY, publicKey);
+
+    // Update cache
+    KeyManager.cachedPublicKey = publicKey;
+    KeyManager.cachedHasIdentity = true;
+    return publicKey;
+  }
+
+  /**
+   * Get the stored private key
+   * WARNING: Only use this for signing operations within the app
+   */
+  static async getPrivateKey() {
+    if (isWebPlatform()) {
+      return null; // Identity storage is only available on native platforms
+    }
+    try {
+      const store = await initSecureStore();
+      return await store.getItemAsync(STORAGE_KEYS.PRIVATE_KEY);
+    } catch (error) {
+      // If secure store is not available, return null (no identity)
+      // This allows the app to continue functioning even if secure store fails to load
+      if (__DEV__) {
+        console.warn('[KeyManager] Failed to access secure store:', error);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Get the stored public key (cached for performance)
+   */
+  static async getPublicKey() {
+    if (isWebPlatform()) {
+      return null; // Identity storage is only available on native platforms
+    }
+    if (KeyManager.cachedPublicKey !== null) {
+      return KeyManager.cachedPublicKey;
+    }
+    try {
+      const store = await initSecureStore();
+      const publicKey = await store.getItemAsync(STORAGE_KEYS.PUBLIC_KEY);
+
+      // Cache result (null is a valid cache value meaning no identity)
+      KeyManager.cachedPublicKey = publicKey;
+      return publicKey;
+    } catch (error) {
+      // If secure store is not available, return null (no identity)
+      // Cache null to avoid repeated failed attempts
+      KeyManager.cachedPublicKey = null;
+      if (__DEV__) {
+        console.warn('[KeyManager] Failed to access secure store:', error);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Check if an identity (key pair) exists on this device (cached for performance)
+   */
+  static async hasIdentity() {
+    if (isWebPlatform()) {
+      return false; // Identity storage is only available on native platforms
+    }
+    if (KeyManager.cachedHasIdentity !== null) {
+      return KeyManager.cachedHasIdentity;
+    }
+    try {
+      const privateKey = await KeyManager.getPrivateKey();
+      const hasIdentity = privateKey !== null;
+
+      // Cache result
+      KeyManager.cachedHasIdentity = hasIdentity;
+      return hasIdentity;
+    } catch (error) {
+      // If we can't check, assume no identity (safer default)
+      // Cache false to avoid repeated failed attempts
+      KeyManager.cachedHasIdentity = false;
+      if (__DEV__) {
+        console.warn('[KeyManager] Failed to check identity:', error);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Delete the stored identity (both keys)
+   * Use with EXTREME caution - this is irreversible without a backup file
+   * This should ONLY be called when explicitly requested by the user
+   * @param skipBackup - If true, skip backup before deletion (default: false)
+   * @param force - If true, skip confirmation checks (default: false)
+   * @param userConfirmed - If true, user has explicitly confirmed deletion (default: false)
+   */
+  static async deleteIdentity(skipBackup = false, force = false, userConfirmed = false) {
+    if (isWebPlatform()) {
+      return; // Identity storage is only available on native platforms, nothing to delete
+    }
+    // CRITICAL SAFEGUARD: Require explicit user confirmation unless force is true
+    if (!force && !userConfirmed) {
+      throw new Error('Identity deletion requires explicit user confirmation. This is a safety measure to prevent accidental data loss.');
+    }
+    if (!force) {
+      const hasIdentity = await KeyManager.hasIdentity();
+      if (!hasIdentity) {
+        return; // Nothing to delete
+      }
+    }
+    const store = await initSecureStore();
+
+    // ALWAYS create backup before deletion unless explicitly skipped
+    if (!skipBackup) {
+      try {
+        const backupSuccess = await KeyManager.backupIdentity();
+        if (!backupSuccess && typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.warn('[KeyManager] Failed to backup identity before deletion - proceeding anyway');
+        }
+      } catch (backupError) {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.warn('[KeyManager] Failed to backup identity before deletion:', backupError);
+        }
+      }
+    }
+    await store.deleteItemAsync(STORAGE_KEYS.PRIVATE_KEY);
+    await store.deleteItemAsync(STORAGE_KEYS.PUBLIC_KEY);
+
+    // Invalidate cache
+    KeyManager.invalidateCache();
+
+    // Also clear backup if force deletion
+    if (force) {
+      try {
+        await store.deleteItemAsync(STORAGE_KEYS.BACKUP_PRIVATE_KEY);
+        await store.deleteItemAsync(STORAGE_KEYS.BACKUP_PUBLIC_KEY);
+        await store.deleteItemAsync(STORAGE_KEYS.BACKUP_TIMESTAMP);
+      } catch (error) {
+        // Ignore backup deletion errors
+      }
+    }
+  }
+
+  /**
+   * Backup identity to SecureStore (separate backup storage)
+   * This provides a recovery mechanism if primary storage fails
+   */
+  static async backupIdentity() {
+    if (isWebPlatform()) {
+      return false; // Identity storage is only available on native platforms
+    }
+    try {
+      const store = await initSecureStore();
+      const privateKey = await KeyManager.getPrivateKey();
+      const publicKey = await KeyManager.getPublicKey();
+      if (!privateKey || !publicKey) {
+        return false; // Nothing to backup
+      }
+
+      // Store backup in SecureStore (still secure, but separate from primary storage)
+      await store.setItemAsync(STORAGE_KEYS.BACKUP_PRIVATE_KEY, privateKey, {
+        keychainAccessible: store.WHEN_UNLOCKED_THIS_DEVICE_ONLY
+      });
+      await store.setItemAsync(STORAGE_KEYS.BACKUP_PUBLIC_KEY, publicKey);
+      await store.setItemAsync(STORAGE_KEYS.BACKUP_TIMESTAMP, Date.now().toString());
+      return true;
+    } catch (error) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.error('[KeyManager] Failed to backup identity:', error);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Verify identity integrity - checks if keys are valid and accessible
+   */
+  static async verifyIdentityIntegrity() {
+    if (isWebPlatform()) {
+      return false; // Identity storage is only available on native platforms
+    }
+    try {
+      const privateKey = await KeyManager.getPrivateKey();
+      const publicKey = await KeyManager.getPublicKey();
+      if (!privateKey || !publicKey) {
+        return false;
+      }
+
+      // Validate private key format
+      if (!KeyManager.isValidPrivateKey(privateKey)) {
+        return false;
+      }
+
+      // Validate public key format
+      if (!KeyManager.isValidPublicKey(publicKey)) {
+        return false;
+      }
+
+      // Verify public key can be derived from private key
+      const derivedPublicKey = KeyManager.derivePublicKey(privateKey);
+      if (derivedPublicKey !== publicKey) {
+        return false; // Keys don't match
+      }
+
+      // Verify we can create a key pair object (tests elliptic curve operations)
+      const keyPair = await KeyManager.getKeyPairObject();
+      if (!keyPair) {
+        return false;
+      }
+      return true;
+    } catch (error) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.error('[KeyManager] Identity integrity check failed:', error);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Restore identity from backup if primary storage is corrupted
+   */
+  static async restoreIdentityFromBackup() {
+    if (isWebPlatform()) {
+      return false; // Identity storage is only available on native platforms
+    }
+    try {
+      const store = await initSecureStore();
+
+      // Check if backup exists
+      const backupPrivateKey = await store.getItemAsync(STORAGE_KEYS.BACKUP_PRIVATE_KEY);
+      const backupPublicKey = await store.getItemAsync(STORAGE_KEYS.BACKUP_PUBLIC_KEY);
+      if (!backupPrivateKey || !backupPublicKey) {
+        return false; // No backup available
+      }
+
+      // Verify backup integrity
+      if (!KeyManager.isValidPrivateKey(backupPrivateKey)) {
+        return false;
+      }
+      if (!KeyManager.isValidPublicKey(backupPublicKey)) {
+        return false;
+      }
+
+      // Verify keys match
+      const derivedPublicKey = KeyManager.derivePublicKey(backupPrivateKey);
+      if (derivedPublicKey !== backupPublicKey) {
+        return false; // Backup keys don't match
+      }
+      await store.setItemAsync(STORAGE_KEYS.PRIVATE_KEY, backupPrivateKey, {
+        keychainAccessible: store.WHEN_UNLOCKED_THIS_DEVICE_ONLY
+      });
+      await store.setItemAsync(STORAGE_KEYS.PUBLIC_KEY, backupPublicKey);
+      const restored = await KeyManager.verifyIdentityIntegrity();
+      if (restored) {
+        // Update cache
+        KeyManager.cachedPublicKey = backupPublicKey;
+        KeyManager.cachedHasIdentity = true;
+        await store.setItemAsync(STORAGE_KEYS.BACKUP_TIMESTAMP, Date.now().toString());
+        return true;
+      }
+      return false;
+    } catch (error) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.error('[KeyManager] Failed to restore identity from backup:', error);
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Get the elliptic curve key object from the stored private key
+   * Used internally for signing operations
+   */
+  static async getKeyPairObject() {
+    if (isWebPlatform()) {
+      return null; // Identity storage is only available on native platforms
+    }
+    const privateKey = await KeyManager.getPrivateKey();
+    if (!privateKey) return null;
+    return ec.keyFromPrivate(privateKey);
+  }
+
+  /**
+   * Derive public key from a private key (without storing)
+   */
+  static derivePublicKey(privateKey) {
+    const keyPair = ec.keyFromPrivate(privateKey);
+    return keyPair.getPublic('hex');
+  }
+
+  /**
+   * Validate that a string is a valid public key
+   */
+  static isValidPublicKey(publicKey) {
+    try {
+      ec.keyFromPublic(publicKey, 'hex');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Validate that a string is a valid private key
+   */
+  static isValidPrivateKey(privateKey) {
+    try {
+      const keyPair = ec.keyFromPrivate(privateKey);
+      // Verify it can derive a public key
+      keyPair.getPublic('hex');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get a shortened version of the public key for display
+   * Format: first 8 chars...last 8 chars
+   */
+  static shortenPublicKey(publicKey) {
+    if (publicKey.length <= 20) return publicKey;
+    return `${publicKey.slice(0, 8)}...${publicKey.slice(-8)}`;
+  }
+}
+export default KeyManager;
+//# sourceMappingURL=keyManager.js.map

package/lib/module/crypto/keyManager.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ec","EC","Platform","SecureStore","ExpoCrypto","STORAGE_KEYS","PRIVATE_KEY","PUBLIC_KEY","BACKUP_PRIVATE_KEY","BACKUP_PUBLIC_KEY","BACKUP_TIMESTAMP","initSecureStore","error","errorMessage","Error","message","String","isReactNative","navigator","product","isNodeJS","process","versions","node","isWebPlatform","OS","window","initExpoCrypto","uint8ArrayToHex","bytes","Array","from","map","b","toString","padStart","join","getSecureRandomBytes","length","Crypto","getRandomBytes","getCrypto","Function","crypto","Uint8Array","randomBytes","KeyManager","cachedPublicKey","cachedHasIdentity","invalidateCache","generateKeyPairSync","keyPair","genKeyPair","privateKey","getPrivate","publicKey","getPublic","generateKeyPair","privateKeyHex","keyFromPrivate","createIdentity","store","setItemAsync","keychainAccessible","WHEN_UNLOCKED_THIS_DEVICE_ONLY","importKeyPair","getPrivateKey","getItemAsync","__DEV__","console","warn","getPublicKey","hasIdentity","deleteIdentity","skipBackup","force","userConfirmed","backupSuccess","backupIdentity","backupError","deleteItemAsync","Date","now","verifyIdentityIntegrity","isValidPrivateKey","isValidPublicKey","derivedPublicKey","derivePublicKey","getKeyPairObject","restoreIdentityFromBackup","backupPrivateKey","backupPublicKey","restored","keyFromPublic","shortenPublicKey","slice"],"sourceRoot":"../../../src","sources":["crypto/keyManager.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/crypto/polyfill.js

@@ -0,0 +1,78 @@
+"use strict";
+
+/**
+ * Crypto Polyfills for React Native
+ * 
+ * This file ensures that required polyfills are available
+ * before any crypto operations are performed.
+ * 
+ * Polyfills included:
+ * - Buffer: Required by crypto libraries
+ * - crypto.getRandomValues: Required for secure random number generation
+ */
+
+// Import Buffer polyfill for React Native compatibility
+// Some crypto libraries depend on Buffer which isn't available in React Native
+import { Buffer } from 'buffer';
+
+// Get the global object in a cross-platform way
+const getGlobalObject = () => {
+  if (typeof globalThis !== 'undefined') return globalThis;
+  if (typeof global !== 'undefined') return global;
+  if (typeof window !== 'undefined') return window;
+  if (typeof self !== 'undefined') return self;
+  return {};
+};
+const globalObject = getGlobalObject();
+
+// Make Buffer available globally for libraries that depend on it
+if (!globalObject.Buffer) {
+  globalObject.Buffer = Buffer;
+}
+
+// Polyfill crypto.getRandomValues for React Native
+// This is required by crypto libraries for secure random number generation
+
+// Cache for expo-crypto module
+let expoCryptoModule = null;
+
+/**
+ * Get random bytes using expo-crypto (synchronous)
+ * This is a synchronous wrapper that loads expo-crypto lazily
+ */
+function getRandomBytesSync(byteCount) {
+  if (!expoCryptoModule) {
+    // Try to require expo-crypto synchronously
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      expoCryptoModule = require('expo-crypto');
+    } catch {
+      throw new Error('expo-crypto is required for crypto.getRandomValues polyfill');
+    }
+  }
+  // TypeScript guard - expoCryptoModule is guaranteed to be non-null here
+  const cryptoModule = expoCryptoModule;
+  if (!cryptoModule) {
+    throw new Error('Failed to load expo-crypto module');
+  }
+  return cryptoModule.getRandomBytes(byteCount);
+}
+const cryptoPolyfill = {
+  getRandomValues(array) {
+    const bytes = getRandomBytesSync(array.byteLength);
+    const uint8View = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    uint8View.set(bytes);
+    return array;
+  }
+};
+
+// Only polyfill if crypto or crypto.getRandomValues is not available
+if (typeof globalObject.crypto === 'undefined') {
+  globalObject.crypto = cryptoPolyfill;
+} else if (typeof globalObject.crypto.getRandomValues !== 'function') {
+  globalObject.crypto.getRandomValues = cryptoPolyfill.getRandomValues;
+}
+
+// Re-export Buffer for convenience
+export { Buffer };
+//# sourceMappingURL=polyfill.js.map

package/lib/module/crypto/polyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Buffer","getGlobalObject","globalThis","global","window","self","globalObject","expoCryptoModule","getRandomBytesSync","byteCount","require","Error","cryptoModule","getRandomBytes","cryptoPolyfill","getRandomValues","array","bytes","byteLength","uint8View","Uint8Array","buffer","byteOffset","set","crypto"],"sourceRoot":"../../../src","sources":["crypto/polyfill.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,SAASA,MAAM,QAAQ,QAAQ;;AAE/B;AACA,MAAMC,eAAe,GAAGA,CAAA,KAAyB;EAC/C,IAAI,OAAOC,UAAU,KAAK,WAAW,EAAE,OAAOA,UAAU;EACxD,IAAI,OAAOC,MAAM,KAAK,WAAW,EAAE,OAAOA,MAAM;EAChD,IAAI,OAAOC,MAAM,KAAK,WAAW,EAAE,OAAOA,MAAM;EAChD,IAAI,OAAOC,IAAI,KAAK,WAAW,EAAE,OAAOA,IAAI;EAC5C,OAAO,CAAC,CAAC;AACX,CAAC;AAED,MAAMC,YAAY,GAAGL,eAAe,CAAC,CAAC;;AAEtC;AACA,IAAI,CAACK,YAAY,CAACN,MAAM,EAAE;EACvBM,YAAY,CAA0CN,MAAM,GAAGA,MAAM;AACxE;;AAEA;AACA;;AAKA;AACA,IAAIO,gBAAqD,GAAG,IAAI;;AAEhE;AACA;AACA;AACA;AACA,SAASC,kBAAkBA,CAACC,SAAiB,EAAc;EACzD,IAAI,CAACF,gBAAgB,EAAE;IACrB;IACA,IAAI;MACF;MACAA,gBAAgB,GAAGG,OAAO,CAAC,aAAa,CAAC;IAC3C,CAAC,CAAC,MAAM;MACN,MAAM,IAAIC,KAAK,CAAC,6DAA6D,CAAC;IAChF;EACF;EACA;EACA,MAAMC,YAAY,GAAGL,gBAAgB;EACrC,IAAI,CAACK,YAAY,EAAE;IACjB,MAAM,IAAID,KAAK,CAAC,mCAAmC,CAAC;EACtD;EACA,OAAOC,YAAY,CAACC,cAAc,CAACJ,SAAS,CAAC;AAC/C;AAEA,MAAMK,cAA0B,GAAG;EACjCC,eAAeA,CAA4BC,KAAQ,EAAK;IACtD,MAAMC,KAAK,GAAGT,kBAAkB,CAACQ,KAAK,CAACE,UAAU,CAAC;IAClD,MAAMC,SAAS,GAAG,IAAIC,UAAU,CAACJ,KAAK,CAACK,MAAM,EAAEL,KAAK,CAACM,UAAU,EAAEN,KAAK,CAACE,UAAU,CAAC;IAClFC,SAAS,CAACI,GAAG,CAACN,KAAK,CAAC;IACpB,OAAOD,KAAK;EACd;AACF,CAAC;;AAED;AACA,IAAI,OAAOV,YAAY,CAACkB,MAAM,KAAK,WAAW,EAAE;EAC7ClB,YAAY,CAAuCkB,MAAM,GAAGV,cAAc;AAC7E,CAAC,MAAM,IAAI,OAAOR,YAAY,CAACkB,MAAM,CAACT,eAAe,KAAK,UAAU,EAAE;EACnET,YAAY,CAACkB,MAAM,CAAgBT,eAAe,GAAGD,cAAc,CAACC,eAAe;AACtF;;AAEA;AACA,SAASf,MAAM","ignoreList":[]}