@aztec/wallet-sdk 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

package/dest/{providers/extension → extension/provider}/extension_wallet.js

@@ -1,35 +1,35 @@
 import { WalletSchema } from '@aztec/aztec.js/wallet';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { promiseWithResolvers } from '@aztec/foundation/promise';
-import { schemaHasMethod } from '@aztec/foundation/schemas';
+import { getSchemaReturnType, schemaHasMethod } from '@aztec/foundation/schemas';
 import { decrypt, encrypt } from '../../crypto.js';
-import { WalletMessageType } from '../../types.js';
+import { DEFAULT_HEARTBEAT_DEAD_AFTER_MS, DEFAULT_HEARTBEAT_INTERVAL_MS, NOOP_LOGGER, WalletMessageType } from '../../types.js';
 /**
  * A wallet implementation that communicates with browser extension wallets
- * using a secure encrypted MessageChannel.
+ * using an encrypted MessageChannel.
  *
- * This class uses a pre-established secure channel from the discovery phase:
+ * This class uses a secure channel established after discovery:
  *
- * 1. **MessageChannel**: A private communication channel created during discovery,
- *    not visible to other scripts on the page (unlike window.postMessage).
+ * 1. **MessageChannel**: Created during discovery and transferred via window.postMessage.
+ *    Note: The port transfer is visible to page scripts, but security comes from encryption.
  *
- * 2. **ECDH Key Exchange**: The shared secret was derived during discovery using
- *    Elliptic Curve Diffie-Hellman key exchange.
+ * 2. **ECDH Key Exchange**: The shared secret was derived after discovery using
+ *    Elliptic Curve Diffie-Hellman key exchange over the MessagePort.
  *
  * 3. **AES-GCM Encryption**: All messages are encrypted using AES-256-GCM,
- *    providing both confidentiality and authenticity.
+ *    providing both confidentiality and authenticity. This is what secures the channel.
  *
  * @example
  * ```typescript
- * // Discovery returns wallets with secure channel components
- * const wallets = await ExtensionProvider.discoverExtensions(chainInfo);
- * const { info, port, sharedKey } = wallets[0];
+ * // Discover and establish secure channel to a wallet
+ * const discoveredWallets = await ExtensionProvider.discoverWallets(chainInfo, { appId: 'my-dapp' });
+ * const connection = await discoveredWallets[0].establishSecureChannel();
  *
  * // User can verify emoji if desired
- * console.log('Verify:', hashToEmoji(info.verificationHash!));
+ * console.log('Verify:', hashToEmoji(connection.info.verificationHash!));
  *
- * // Create wallet using the discovered components
- * const wallet = await ExtensionWallet.create(info, chainInfo, port, sharedKey, 'my-dapp');
+ * // Create wallet using the connection
+ * const wallet = ExtensionWallet.create(connection.info.id, connection.port, connection.sharedKey, chainInfo, 'my-dapp');
  *
  * // All subsequent calls are encrypted
  * const accounts = await wallet.getAccounts();
@@ -43,6 +43,11 @@ import { WalletMessageType } from '../../types.js';
     /** Map of pending requests awaiting responses, keyed by message ID */ inFlight;
     disconnected;
     disconnectCallbacks;
+    heartbeatTimer;
+    lastInboundAt;
+    log;
+    heartbeatIntervalMs;
+    heartbeatDeadAfterMs;
     /**
    * Private constructor - use {@link ExtensionWallet.create} to instantiate.
    * @param chainInfo - The chain information (chainId and version)
@@ -50,7 +55,9 @@ import { WalletMessageType } from '../../types.js';
    * @param extensionId - The unique identifier of the target wallet extension
    * @param port - The MessagePort for private communication with the wallet
    * @param sharedKey - The derived AES-256-GCM shared key for encryption
-   */ constructor(chainInfo, appId, extensionId, port, sharedKey){
+   * @param logger - Optional logger; defaults to a no-op logger
+   * @param heartbeatOptions - Optional heartbeat tuning (mostly useful for tests)
+   */ constructor(chainInfo, appId, extensionId, port, sharedKey, logger, heartbeatOptions){
         this.chainInfo = chainInfo;
         this.appId = appId;
         this.extensionId = extensionId;
@@ -59,83 +66,76 @@ import { WalletMessageType } from '../../types.js';
         this.inFlight = new Map();
         this.disconnected = false;
         this.disconnectCallbacks = [];
-        this.walletProxy = null;
+        this.heartbeatTimer = null;
+        this.lastInboundAt = 0;
+        this.log = logger ?? NOOP_LOGGER;
+        this.heartbeatIntervalMs = heartbeatOptions?.intervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+        this.heartbeatDeadAfterMs = heartbeatOptions?.deadAfterMs ?? DEFAULT_HEARTBEAT_DEAD_AFTER_MS;
     }
-    /** Cached Wallet proxy instance */ walletProxy;
     /**
-   * Creates an ExtensionWallet instance that communicates with a browser extension
+   * Creates a Wallet that communicates with a browser extension
    * over a secure encrypted MessageChannel.
    *
-   * @param walletInfo - The wallet info from ExtensionProvider.discoverExtensions()
-   * @param chainInfo - The chain information (chainId and version) for request context
-   * @param port - The MessagePort for private communication with the wallet
+   * @param extensionId - The unique identifier of the wallet extension
+   * @param port - The MessagePort for encrypted communication with the wallet
    * @param sharedKey - The derived AES-256-GCM shared key for encryption
+   * @param chainInfo - The chain information (chainId and version) for request context
    * @param appId - Application identifier used to identify the requesting dApp to the wallet
-   * @returns The ExtensionWallet instance. Use {@link getWallet} to get the Wallet interface.
+   * @param logger - Optional logger; defaults to a no-op logger to keep extension/page bundles small
+   * @param heartbeatOptions - Optional override for heartbeat tuning (mostly useful for tests)
+   * @returns A Wallet interface where all method calls are encrypted
    *
    * @example
    * ```typescript
-   * const wallets = await ExtensionProvider.discoverExtensions(chainInfo);
-   * const { info, port, sharedKey } = wallets[0];
-   * const extensionWallet = ExtensionWallet.create(
-   *   info,
-   *   { chainId: Fr(31337), version: Fr(0) },
-   *   port,
-   *   sharedKey,
+   * const discoveredWallets = await ExtensionProvider.discoverWallets(chainInfo, { appId: 'my-defi-app' });
+   * const connection = await discoveredWallets[0].establishSecureChannel();
+   * const wallet = ExtensionWallet.create(
+   *   connection.info.id,
+   *   connection.port,
+   *   connection.sharedKey,
+   *   chainInfo,
    *   'my-defi-app'
    * );
    *
-   * // Register disconnect handler
-   * extensionWallet.onDisconnect(() => console.log('Disconnected!'));
-   *
-   * // Get the Wallet interface for dApp usage
-   * const wallet = extensionWallet.getWallet();
    * const accounts = await wallet.getAccounts();
    * ```
-   */ static create(walletInfo, chainInfo, port, sharedKey, appId) {
-        const wallet = new ExtensionWallet(chainInfo, appId, walletInfo.id, port, sharedKey);
-        // Set up message handler - all messages are now encrypted
+   */ static create(extensionId, port, sharedKey, chainInfo, appId, logger, heartbeatOptions) {
+        const wallet = new ExtensionWallet(chainInfo, appId, extensionId, port, sharedKey, logger, heartbeatOptions);
+        // Set up message handler for encrypted responses and unencrypted control messages
         wallet.port.onmessage = (event)=>{
-            void wallet.handleEncryptedResponse(event.data);
+            const data = event.data;
+            // Any inbound traffic counts as proof of liveness.
+            wallet.lastInboundAt = Date.now();
+            if (data && typeof data === 'object' && 'type' in data && data.type === WalletMessageType.DISCONNECT) {
+                wallet.handleDisconnect();
+                return;
+            }
+            // Otherwise treat as encrypted payload
+            void wallet.handleEncryptedResponse(data);
         };
         wallet.port.start();
-        return wallet;
-    }
-    /**
-   * Returns a Wallet interface that proxies all method calls through the secure channel.
-   *
-   * The returned Wallet can be used directly by dApps - all method calls are automatically
-   * encrypted and sent to the wallet extension.
-   *
-   * @returns A Wallet implementation that encrypts all communication
-   *
-   * @example
-   * ```typescript
-   * const extensionWallet = ExtensionWallet.create(info, chainInfo, port, sharedKey, 'my-app');
-   * const wallet = extensionWallet.getWallet();
-   * const accounts = await wallet.getAccounts();
-   * ```
-   */ getWallet() {
-        if (this.walletProxy) {
-            return this.walletProxy;
-        }
-        // Create a Proxy that intercepts wallet method calls and forwards them to the extension
-        this.walletProxy = new Proxy(this, {
-            get: (target, prop)=>{
-                if (schemaHasMethod(WalletSchema, prop.toString())) {
+        return new Proxy(wallet, {
+            get: (target, prop, receiver)=>{
+                if (prop === 'asWallet') {
+                    return ()=>receiver;
+                } else if (schemaHasMethod(WalletSchema, prop.toString())) {
                     return async (...args)=>{
                         const result = await target.postMessage({
                             type: prop.toString(),
                             args
                         });
-                        return WalletSchema[prop.toString()].returnType().parseAsync(result);
+                        return getSchemaReturnType(WalletSchema[prop.toString()]).parseAsync(result);
                     };
                 } else {
                     return target[prop];
                 }
             }
         });
-        return this.walletProxy;
+    }
+    asWallet() {
+        // Overridden by the proxy in create() to return the proxy itself.
+        // This body is never reached when accessed through create().
+        return this;
     }
     /**
    * Handles an encrypted response received from the wallet extension.
@@ -151,12 +151,6 @@ import { WalletMessageType } from '../../types.js';
         try {
             const response = await decrypt(this.sharedKey, encrypted);
             const { messageId, result, error, walletId: responseWalletId } = response;
-            // Check for disconnect notification from the wallet backend
-            // This is sent as an encrypted error response with a special type
-            if (error && typeof error === 'object' && 'type' in error && error.type === WalletMessageType.SESSION_DISCONNECTED) {
-                this.handleDisconnect();
-                return;
-            }
             if (!messageId || !responseWalletId) {
                 return;
             }
@@ -173,8 +167,12 @@ import { WalletMessageType } from '../../types.js';
                 resolve(result);
             }
             this.inFlight.delete(messageId);
-        // eslint-disable-next-line no-empty
-        } catch  {}
+            this.maybeStopHeartbeat();
+        } catch (err) {
+            this.log.warn('Failed to decrypt wallet response', {
+                err
+            });
+        }
     }
     /**
    * Sends an encrypted wallet method call over the secure MessageChannel.
@@ -203,8 +201,7 @@ import { WalletMessageType } from '../../types.js';
             appId: this.appId,
             walletId: this.extensionId
         };
-        // Encrypt the message and send over the private MessageChannel
-        const encrypted = await encrypt(this.sharedKey, message);
+        const encrypted = await encrypt(this.sharedKey, jsonStringify(message));
         this.port.postMessage(encrypted);
         const { promise, resolve, reject } = promiseWithResolvers();
         this.inFlight.set(messageId, {
@@ -212,9 +209,57 @@ import { WalletMessageType } from '../../types.js';
             resolve,
             reject
         });
+        this.startHeartbeat();
         return promise;
     }
     /**
+   * Start the heartbeat probe loop while at least one request is in flight.
+   * Idempotent — calling while already running is a no-op.
+   *
+   * Heartbeat is opt-in via wire protocol: PINGs are unencrypted control messages
+   * (like DISCONNECT). Older wallets that do not understand PING simply drop it,
+   * which is safe — we only declare disconnect when **no** inbound traffic of any
+   * kind (PONG, encrypted response, DISCONNECT) arrives within the dead window.
+   * A wallet that is processing a slow request will reset the timer when it
+   * eventually responds, so this never causes false disconnects on legacy peers.
+   */ startHeartbeat() {
+        if (this.heartbeatTimer !== null || this.disconnected) {
+            return;
+        }
+        this.lastInboundAt = Date.now();
+        this.heartbeatTimer = setInterval(()=>this.heartbeatTick(), this.heartbeatIntervalMs);
+    }
+    maybeStopHeartbeat() {
+        if (this.inFlight.size === 0 && this.heartbeatTimer !== null) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    heartbeatTick() {
+        if (this.disconnected || this.inFlight.size === 0) {
+            this.maybeStopHeartbeat();
+            return;
+        }
+        const idleMs = Date.now() - this.lastInboundAt;
+        if (idleMs >= this.heartbeatDeadAfterMs) {
+            this.log.warn('Wallet channel unresponsive — declaring disconnect', {
+                idleMs,
+                inFlight: this.inFlight.size
+            });
+            this.handleDisconnect();
+            return;
+        }
+        try {
+            this.port.postMessage({
+                type: WalletMessageType.PING
+            });
+        } catch (err) {
+            this.log.warn('Failed to send heartbeat PING', {
+                err
+            });
+        }
+    }
+    /**
    * Handles wallet disconnection.
    * Rejects all pending requests and notifies registered callbacks.
    * @internal
@@ -223,25 +268,24 @@ import { WalletMessageType } from '../../types.js';
             return;
         }
         this.disconnected = true;
-        // Close the port to prevent any further messages
+        if (this.heartbeatTimer !== null) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
         if (this.port) {
             this.port.onmessage = null;
             this.port.close();
         }
-        // Reject all pending requests
-        // Note: These rejections should be caught by the callers, but we log them
-        // here to help with debugging if they become unhandled
         const error = new Error('Wallet disconnected');
         for (const { reject } of this.inFlight.values()){
             reject(error);
         }
         this.inFlight.clear();
-        // Notify registered callbacks
         for (const callback of this.disconnectCallbacks){
             try {
                 callback();
             } catch  {
-            // Ignore errors in callbacks
+            // Ignore errors on disconnect callbacks
             }
         }
     }
@@ -285,34 +329,21 @@ import { WalletMessageType } from '../../types.js';
    *
    * @example
    * ```typescript
-   * const wallet = await provider.connect('my-app');
+   * const extensionWallet = ExtensionWallet.create(extensionId, port, sharedKey, chainInfo, 'my-app');
    * // ... use wallet ...
-   * await wallet.disconnect(); // Clean disconnect when done
+   * await extensionWallet.disconnect(); // Clean disconnect when done
    * ```
-   */ async disconnect() {
+   */ // eslint-disable-next-line require-await -- async for interface compatibility
+    async disconnect() {
         if (this.disconnected) {
             return;
         }
-        // Send disconnect message to extension before closing
-        if (this.port && this.sharedKey) {
-            try {
-                const message = {
-                    type: WalletMessageType.DISCONNECT,
-                    messageId: globalThis.crypto.randomUUID(),
-                    chainInfo: this.chainInfo,
-                    appId: this.appId,
-                    walletId: this.extensionId,
-                    args: []
-                };
-                const encrypted = await encrypt(this.sharedKey, message);
-                this.port.postMessage(encrypted);
-            } catch  {
-            // Ignore errors sending disconnect message
-            }
-        }
-        this.handleDisconnect();
         if (this.port) {
-            this.port.close();
+            // Send unencrypted disconnect - control messages don't need encryption
+            this.port.postMessage({
+                type: WalletMessageType.DISCONNECT
+            });
         }
+        this.handleDisconnect();
     }
 }

package/dest/extension/provider/index.d.ts

@@ -0,0 +1,3 @@
+export { ExtensionWallet } from './extension_wallet.js';
+export { ExtensionProvider, type DiscoveredWallet, type ConnectedWallet, type DiscoveryOptions, } from './extension_provider.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9leHRlbnNpb24vcHJvdmlkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3hELE9BQU8sRUFDTCxpQkFBaUIsRUFDakIsS0FBSyxnQkFBZ0IsRUFDckIsS0FBSyxlQUFlLEVBQ3BCLEtBQUssZ0JBQWdCLEdBQ3RCLE1BQU0seUJBQXlCLENBQUMifQ==

package/dest/extension/provider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extension/provider/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EACL,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,yBAAyB,CAAC"}

package/dest/{providers/extension → extension/provider}/index.js

@@ -1,4 +1,2 @@
 export { ExtensionWallet } from './extension_wallet.js';
 export { ExtensionProvider } from './extension_provider.js';
-export * from '../../crypto.js';
-export { WalletMessageType } from '../../types.js';

package/dest/iframe/handlers/iframe_connection_handler.d.ts

@@ -0,0 +1,122 @@
+/**
+ * IframeConnectionHandler — wallet-side of the cross-origin iframe protocol.
+ *
+ * This mirrors {@link BackgroundConnectionHandler} from `@aztec/wallet-sdk/extension/handlers`
+ * but uses `window.postMessage` instead of browser.runtime messaging.
+ *
+ * Message flow (wallet receives):
+ *   parent → DISCOVERY            → show approval UI → send DISCOVERY_RESPONSE
+ *   parent → KEY_EXCHANGE_REQUEST → ECDH             → send KEY_EXCHANGE_RESPONSE
+ *   parent → SECURE_MESSAGE       → decrypt → Wallet → encrypt → SECURE_RESPONSE
+ *   parent → DISCONNECT           → terminate session
+ *
+ * The wallet announces itself by posting WALLET_READY as soon as the handler starts,
+ * so the dApp knows it can send a discovery request.
+ */
+import type { ChainInfo } from '@aztec/aztec.js/account';
+import type { Wallet } from '@aztec/aztec.js/wallet';
+import { type WalletSdkLogger } from '../../types.js';
+/**
+ * A pending discovery request from a dApp (before user approval).
+ */
+export interface PendingSession {
+    /** Unique request identifier */
+    requestId: string;
+    /** Application identifier */
+    appId: string;
+    /** Origin URL of the requesting page */
+    origin: string;
+    /** Approval status */
+    status: 'pending' | 'approved';
+}
+/**
+ * An active session (after key exchange).
+ */
+export interface ActiveSession {
+    /** Session identifier (same as the discovery requestId) */
+    sessionId: string;
+    /** AES-256-GCM shared key for this session */
+    sharedKey: CryptoKey;
+    /** Verification hash for emoji display */
+    verificationHash: string;
+    /** Origin URL of the connected dApp */
+    origin: string;
+    /** Application identifier */
+    appId: string;
+}
+/**
+ * Configuration for the iframe connection handler.
+ */
+export interface IframeConnectionConfig {
+    /** Unique wallet identifier */
+    walletId: string;
+    /** Display name for the wallet */
+    walletName: string;
+    /** Wallet version string */
+    walletVersion: string;
+    /** Optional wallet icon URL */
+    walletIcon?: string;
+    /** Origins allowed to connect. If empty or undefined, all origins are allowed (dev mode). */
+    allowedOrigins?: string[];
+    /** Logger used for diagnostics. */
+    logger: WalletSdkLogger;
+}
+/**
+ * Event callbacks for the iframe connection handler.
+ */
+export interface IframeConnectionCallbacks {
+    /** Called when a new discovery request arrives — wallet can show approval UI */
+    onPendingDiscovery?: (session: PendingSession) => void;
+    /** Called when a session is established (key exchange complete) */
+    onSessionEstablished?: (session: ActiveSession) => void;
+    /** Called when a session is terminated */
+    onSessionTerminated?: (sessionId: string) => void;
+    /** Called when a key exchange completes — show verificationHash as emojis to the user */
+    onVerificationHash?: (verificationHash: string) => void;
+    /**
+     * Resolves the Wallet instance to use for a given dApp and chain.
+     * Called when an encrypted message arrives and needs to be dispatched.
+     */
+    getWallet: (appId: string, chainInfo: ChainInfo) => Promise<Wallet>;
+}
+/**
+ * Handles the wallet side of the cross-origin iframe protocol.
+ *
+ * Manages the full lifecycle: discovery, ECDH key exchange, encrypted message
+ * dispatch to a {@link Wallet} instance, and session termination.
+ *
+ * @example
+ * ```typescript
+ * const handler = new IframeConnectionHandler(
+ *   { walletId: 'my-wallet', walletName: 'My Wallet', walletVersion: '1.0.0', logger: console },
+ *   {
+ *     onPendingDiscovery: (session) => showApprovalUI(session),
+ *     getWallet: (appId, chainInfo) => createWalletForApp(appId, chainInfo),
+ *   },
+ * );
+ * handler.start();
+ * ```
+ */
+export declare class IframeConnectionHandler {
+    private config;
+    private callbacks;
+    private pendingSessions;
+    private activeSessions;
+    private log;
+    constructor(config: IframeConnectionConfig, callbacks: IframeConnectionCallbacks);
+    start(): void;
+    stop(): void;
+    approveDiscovery(requestId: string): void;
+    rejectDiscovery(requestId: string): void;
+    terminateSession(sessionId: string): void;
+    getPendingSessions(): PendingSession[];
+    private handleMessage;
+    private handleMessageAsync;
+    private handlePing;
+    private handleDiscoveryRequest;
+    private handleKeyExchangeRequest;
+    private handleSecureMessage;
+    private postToParent;
+    private postToOrigin;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/iframe/handlers/iframe_connection_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iframe_connection_handler.d.ts","sourceRoot":"","sources":["../../../src/iframe/handlers/iframe_connection_handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAcrD,OAAO,EAA8D,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAElH;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,sBAAsB;IACtB,MAAM,EAAE,SAAS,GAAG,UAAU,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,SAAS,EAAE,SAAS,CAAC;IACrB,0CAA0C;IAC1C,gBAAgB,EAAE,MAAM,CAAC;IACzB,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,4BAA4B;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,+BAA+B;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6FAA6F;IAC7F,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,mCAAmC;IACnC,MAAM,EAAE,eAAe,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,kFAAgF;IAChF,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IACvD,mEAAmE;IACnE,oBAAoB,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,CAAC;IACxD,0CAA0C;IAC1C,mBAAmB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAClD,2FAAyF;IACzF,kBAAkB,CAAC,EAAE,CAAC,gBAAgB,EAAE,MAAM,KAAK,IAAI,CAAC;IACxD;;;OAGG;IACH,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACrE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,uBAAuB;IAMhC,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS;IANnB,OAAO,CAAC,eAAe,CAAqC;IAC5D,OAAO,CAAC,cAAc,CAAoC;IAC1D,OAAO,CAAC,GAAG,CAAkB;IAE7B,YACU,MAAM,EAAE,sBAAsB,EAC9B,SAAS,EAAE,yBAAyB,EAG7C;IAED,KAAK,IAAI,IAAI,CAIZ;IAED,IAAI,IAAI,IAAI,CAEX;IAED,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAkBxC;IAED,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAEvC;IAED,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAUxC;IAED,kBAAkB,IAAI,cAAc,EAAE,CAErC;IAED,OAAO,CAAC,aAAa,CAEnB;YAEY,kBAAkB;IA+BhC,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,sBAAsB;YAShB,wBAAwB;YA6CxB,mBAAmB;IAqDjC,OAAO,CAAC,YAAY;IAMpB,OAAO,CAAC,YAAY;CAKrB"}