@aboutcircles/sdk-runner 0.1.0

package/dist/runner.d.ts

@@ -0,0 +1,3 @@
+import type { BatchRun, ContractRunner } from '@aboutcircles/sdk-types';
+export type { BatchRun, ContractRunner };
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA+B,QAAQ,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAIrG,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/dist/runner.js

@@ -0,0 +1 @@
+export {};

package/dist/safe-browser-runner.d.ts

@@ -0,0 +1,130 @@
+import type { Address, TransactionRequest } from '@aboutcircles/sdk-types';
+import type { ContractRunner, BatchRun } from './runner';
+import type { PublicClient, TransactionReceipt, Chain } from 'viem';
+import type { EIP1193Provider } from 'viem';
+/**
+ * Safe browser contract runner implementation using Safe Protocol Kit
+ * Executes transactions through a Safe multisig wallet using the browser's Web3 provider
+ *
+ * This runner is designed for use in browser environments where the user has a Web3 wallet
+ * extension installed (e.g., MetaMask, WalletConnect, etc.)
+ */
+export declare class SafeBrowserRunner implements ContractRunner {
+    address?: Address;
+    publicClient: PublicClient;
+    private eip1193Provider;
+    private safeAddress?;
+    private safe?;
+    /**
+     * Creates a new SafeBrowserRunner
+     * @param publicClient - The viem public client for reading blockchain state
+     * @param eip1193Provider - The EIP-1193 provider from the browser (e.g., window.ethereum)
+     * @param safeAddress - The address of the Safe wallet (optional, can be set in init)
+     *
+     * @example
+     * ```typescript
+     * import { createPublicClient, http } from 'viem';
+     * import { gnosis } from 'viem/chains';
+     * import { SafeBrowserRunner } from '@aboutcircles/sdk-runner';
+     *
+     * const publicClient = createPublicClient({
+     *   chain: gnosis,
+     *   transport: http('https://rpc.gnosischain.com')
+     * });
+     *
+     * const runner = new SafeBrowserRunner(
+     *   publicClient,
+     *   window.ethereum,
+     *   '0xYourSafeAddress...'
+     * );
+     *
+     * await runner.init();
+     * ```
+     */
+    constructor(publicClient: PublicClient, eip1193Provider: EIP1193Provider, safeAddress?: Address);
+    /**
+     * Create and initialize a SafeBrowserRunner in one step
+     * @param rpcUrl - The RPC URL to connect to
+     * @param eip1193Provider - The EIP-1193 provider from the browser (e.g., window.ethereum)
+     * @param safeAddress - The address of the Safe wallet
+     * @param chain - The viem chain configuration (e.g., gnosis from 'viem/chains')
+     * @returns An initialized SafeBrowserRunner instance
+     *
+     * @example
+     * ```typescript
+     * import { gnosis } from 'viem/chains';
+     * import { SafeBrowserRunner } from '@aboutcircles/sdk-runner';
+     *
+     * const runner = await SafeBrowserRunner.create(
+     *   'https://rpc.gnosischain.com',
+     *   window.ethereum,
+     *   '0xYourSafeAddress...',
+     *   gnosis
+     * );
+     * ```
+     */
+    static create(rpcUrl: string, eip1193Provider: EIP1193Provider, safeAddress: Address, chain: Chain): Promise<SafeBrowserRunner>;
+    /**
+     * Initialize the runner with a Safe address
+     * @param safeAddress - The address of the Safe wallet (optional if provided in constructor)
+     * @throws {RunnerError} If no Safe address is provided and no EIP-1193 provider is available
+     */
+    init(safeAddress?: Address): Promise<void>;
+    /**
+     * Ensures the Safe is initialized
+     * @private
+     */
+    private ensureSafe;
+    /**
+     * Estimate gas for a transaction
+     */
+    estimateGas: (tx: TransactionRequest) => Promise<bigint>;
+    /**
+     * Call a contract (read-only operation)
+     */
+    call: (tx: TransactionRequest) => Promise<string>;
+    /**
+     * Resolve an ENS name to an address
+     */
+    resolveName: (name: string) => Promise<string | null>;
+    /**
+     * Send one or more transactions through the Safe and wait for confirmation
+     * All transactions are batched and executed atomically
+     *
+     * The user will be prompted to sign the transaction through their Web3 wallet
+     *
+     * @throws {RunnerError} If transaction reverts or execution fails
+     */
+    sendTransaction: (txs: TransactionRequest[]) => Promise<TransactionReceipt>;
+    /**
+     * Create a batch transaction runner
+     * @returns A SafeBrowserBatchRun instance for batching multiple transactions
+     */
+    sendBatchTransaction: () => SafeBrowserBatchRun;
+}
+/**
+ * Batch transaction runner for Safe browser operations
+ * Allows multiple transactions to be batched and executed together
+ */
+export declare class SafeBrowserBatchRun implements BatchRun {
+    private readonly safe;
+    private readonly publicClient;
+    private readonly transactions;
+    constructor(safe: any, publicClient: PublicClient);
+    /**
+     * Add a transaction to the batch
+     */
+    addTransaction(tx: TransactionRequest): void;
+    /**
+     * Get the Safe transaction data for all batched transactions
+     */
+    getSafeTransaction(): Promise<any>;
+    /**
+     * Execute all batched transactions and wait for confirmation
+     * The user will be prompted to sign the transaction through their Web3 wallet
+     *
+     * @throws {RunnerError} If transaction reverts or execution fails
+     */
+    run(): Promise<TransactionReceipt>;
+}
+//# sourceMappingURL=safe-browser-runner.d.ts.map

package/dist/safe-browser-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-browser-runner.d.ts","sourceRoot":"","sources":["../src/safe-browser-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAO,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AAY5C;;;;;;GAMG;AACH,qBAAa,iBAAkB,YAAW,cAAc;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;IAElC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,WAAW,CAAC,CAAU;IAC9B,OAAO,CAAC,IAAI,CAAC,CAAM;IAEnB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;gBAED,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,eAAe,EAChC,WAAW,CAAC,EAAE,OAAO;IAOvB;;;;;;;;;;;;;;;;;;;;OAoBG;WACU,MAAM,CACjB,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,eAAe,EAChC,WAAW,EAAE,OAAO,EACpB,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,iBAAiB,CAAC;IAW7B;;;;OAIG;IACG,IAAI,CAAC,WAAW,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBhD;;;OAGG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,WAAW,GAAU,IAAI,kBAAkB,KAAG,OAAO,CAAC,MAAM,CAAC,CAW3D;IAEF;;OAEG;IACH,IAAI,GAAU,IAAI,kBAAkB,KAAG,OAAO,CAAC,MAAM,CAAC,CAapD;IAEF;;OAEG;IACH,WAAW,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAUxD;IAEF;;;;;;;OAOG;IACH,eAAe,GAAU,KAAK,kBAAkB,EAAE,KAAG,OAAO,CAAC,kBAAkB,CAAC,CA0C9E;IAEF;;;OAGG;IACH,oBAAoB,QAAO,mBAAmB,CAG5C;CACH;AAED;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,QAAQ;IAIhD,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAJ/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA4B;gBAGtC,IAAI,EAAE,GAAG,EACT,YAAY,EAAE,YAAY;IAG7C;;OAEG;IACH,cAAc,CAAC,EAAE,EAAE,kBAAkB;IAIrC;;OAEG;IACG,kBAAkB;IAexB;;;;;OAKG;IACG,GAAG,IAAI,OAAO,CAAC,kBAAkB,CAAC;CA0BzC"}

package/dist/safe-browser-runner.js

@@ -0,0 +1,265 @@
+import { createPublicClient, http } from 'viem';
+import { OperationType } from '@safe-global/safe-core-sdk-types';
+import { RunnerError } from './errors';
+// Use require for Safe to ensure compatibility with bun's CJS/ESM interop
+// Safe Protocol Kit v5 uses CommonJS exports, so we use require() for proper interop
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+//@todo double check the import format
+const SafeModule = require('@safe-global/protocol-kit');
+const Safe = SafeModule.default || SafeModule;
+/**
+ * Safe browser contract runner implementation using Safe Protocol Kit
+ * Executes transactions through a Safe multisig wallet using the browser's Web3 provider
+ *
+ * This runner is designed for use in browser environments where the user has a Web3 wallet
+ * extension installed (e.g., MetaMask, WalletConnect, etc.)
+ */
+export class SafeBrowserRunner {
+    address;
+    publicClient;
+    eip1193Provider;
+    safeAddress;
+    safe;
+    /**
+     * Creates a new SafeBrowserRunner
+     * @param publicClient - The viem public client for reading blockchain state
+     * @param eip1193Provider - The EIP-1193 provider from the browser (e.g., window.ethereum)
+     * @param safeAddress - The address of the Safe wallet (optional, can be set in init)
+     *
+     * @example
+     * ```typescript
+     * import { createPublicClient, http } from 'viem';
+     * import { gnosis } from 'viem/chains';
+     * import { SafeBrowserRunner } from '@aboutcircles/sdk-runner';
+     *
+     * const publicClient = createPublicClient({
+     *   chain: gnosis,
+     *   transport: http('https://rpc.gnosischain.com')
+     * });
+     *
+     * const runner = new SafeBrowserRunner(
+     *   publicClient,
+     *   window.ethereum,
+     *   '0xYourSafeAddress...'
+     * );
+     *
+     * await runner.init();
+     * ```
+     */
+    constructor(publicClient, eip1193Provider, safeAddress) {
+        this.publicClient = publicClient;
+        this.eip1193Provider = eip1193Provider;
+        this.safeAddress = safeAddress;
+    }
+    /**
+     * Create and initialize a SafeBrowserRunner in one step
+     * @param rpcUrl - The RPC URL to connect to
+     * @param eip1193Provider - The EIP-1193 provider from the browser (e.g., window.ethereum)
+     * @param safeAddress - The address of the Safe wallet
+     * @param chain - The viem chain configuration (e.g., gnosis from 'viem/chains')
+     * @returns An initialized SafeBrowserRunner instance
+     *
+     * @example
+     * ```typescript
+     * import { gnosis } from 'viem/chains';
+     * import { SafeBrowserRunner } from '@aboutcircles/sdk-runner';
+     *
+     * const runner = await SafeBrowserRunner.create(
+     *   'https://rpc.gnosischain.com',
+     *   window.ethereum,
+     *   '0xYourSafeAddress...',
+     *   gnosis
+     * );
+     * ```
+     */
+    static async create(rpcUrl, eip1193Provider, safeAddress, chain) {
+        const publicClient = createPublicClient({
+            chain,
+            transport: http(rpcUrl),
+        });
+        const runner = new SafeBrowserRunner(publicClient, eip1193Provider, safeAddress);
+        await runner.init();
+        return runner;
+    }
+    /**
+     * Initialize the runner with a Safe address
+     * @param safeAddress - The address of the Safe wallet (optional if provided in constructor)
+     * @throws {RunnerError} If no Safe address is provided and no EIP-1193 provider is available
+     */
+    async init(safeAddress) {
+        // Use provided address or the one from constructor
+        const targetSafeAddress = safeAddress || this.safeAddress;
+        if (!targetSafeAddress) {
+            throw RunnerError.initializationFailed('SafeBrowserRunner', new Error('Safe address must be provided either in constructor or init()'));
+        }
+        if (!this.eip1193Provider) {
+            throw RunnerError.initializationFailed('SafeBrowserRunner', new Error('No EIP-1193 provider available. Make sure you are in a browser environment with a Web3 wallet extension.'));
+        }
+        this.safeAddress = targetSafeAddress;
+        this.address = targetSafeAddress;
+        // Initialize Safe Protocol Kit with browser provider
+        this.safe = await Safe.init({
+            provider: this.eip1193Provider,
+            safeAddress: targetSafeAddress,
+        });
+    }
+    /**
+     * Ensures the Safe is initialized
+     * @private
+     */
+    ensureSafe() {
+        if (!this.safe) {
+            throw RunnerError.initializationFailed('SafeBrowserRunner', new Error('SafeBrowserRunner not initialized. Call init() first.'));
+        }
+        return this.safe;
+    }
+    /**
+     * Estimate gas for a transaction
+     */
+    estimateGas = async (tx) => {
+        const estimate = await this.publicClient.estimateGas({
+            // @ts-expect-error - Address type is compatible with viem's 0x${string}
+            account: this.address,
+            // @ts-expect-error - Address type is compatible with viem's 0x${string}
+            to: tx.to,
+            data: tx.data,
+            value: tx.value,
+        });
+        return estimate;
+    };
+    /**
+     * Call a contract (read-only operation)
+     */
+    call = async (tx) => {
+        const result = await this.publicClient.call({
+            // @ts-expect-error - Address type is compatible with viem's 0x${string}
+            account: tx.from || this.address,
+            // @ts-expect-error - Address type is compatible with viem's 0x${string}
+            to: tx.to,
+            data: tx.data,
+            value: tx.value,
+            gas: tx.gas,
+            gasPrice: tx.gasPrice,
+        });
+        return result.data || '0x';
+    };
+    /**
+     * Resolve an ENS name to an address
+     */
+    resolveName = async (name) => {
+        try {
+            const address = await this.publicClient.getEnsAddress({
+                name,
+            });
+            return address;
+        }
+        catch (error) {
+            // ENS resolution failed or not supported
+            return null;
+        }
+    };
+    /**
+     * Send one or more transactions through the Safe and wait for confirmation
+     * All transactions are batched and executed atomically
+     *
+     * The user will be prompted to sign the transaction through their Web3 wallet
+     *
+     * @throws {RunnerError} If transaction reverts or execution fails
+     */
+    sendTransaction = async (txs) => {
+        const safe = this.ensureSafe();
+        if (txs.length === 0) {
+            throw RunnerError.executionFailed('No transactions provided');
+        }
+        const metaTransactions = txs.map((tx) => ({
+            operation: OperationType.Call,
+            to: tx.to,
+            value: (tx.value?.toString() ?? '0'),
+            data: tx.data ?? '0x',
+        }));
+        // Create Safe transaction with all transactions
+        const safeTransaction = await safe.createTransaction({
+            transactions: metaTransactions,
+        });
+        // Execute the batched transaction (will prompt user for signature)
+        const txResult = await safe.executeTransaction(safeTransaction);
+        if (!txResult.hash) {
+            throw RunnerError.executionFailed('No transaction hash returned from Safe execution');
+        }
+        // Wait for transaction receipt
+        const receipt = await this.publicClient.waitForTransactionReceipt({
+            hash: txResult.hash,
+        });
+        // Check transaction status and throw if reverted
+        if (receipt.status === 'reverted') {
+            throw RunnerError.transactionReverted(receipt.transactionHash, receipt.blockNumber, receipt.gasUsed);
+        }
+        // Return viem's TransactionReceipt directly
+        return receipt;
+    };
+    /**
+     * Create a batch transaction runner
+     * @returns A SafeBrowserBatchRun instance for batching multiple transactions
+     */
+    sendBatchTransaction = () => {
+        const safe = this.ensureSafe();
+        return new SafeBrowserBatchRun(safe, this.publicClient);
+    };
+}
+/**
+ * Batch transaction runner for Safe browser operations
+ * Allows multiple transactions to be batched and executed together
+ */
+export class SafeBrowserBatchRun {
+    safe;
+    publicClient;
+    transactions = [];
+    constructor(safe, publicClient) {
+        this.safe = safe;
+        this.publicClient = publicClient;
+    }
+    /**
+     * Add a transaction to the batch
+     */
+    addTransaction(tx) {
+        this.transactions.push(tx);
+    }
+    /**
+     * Get the Safe transaction data for all batched transactions
+     */
+    async getSafeTransaction() {
+        const metaTransactions = this.transactions.map((tx) => ({
+            operation: OperationType.Call,
+            to: tx.to,
+            value: (tx.value?.toString() ?? '0'),
+            data: tx.data ?? '0x',
+        }));
+        const safeTransaction = await this.safe.createTransaction({
+            transactions: metaTransactions,
+        });
+        return safeTransaction;
+    }
+    /**
+     * Execute all batched transactions and wait for confirmation
+     * The user will be prompted to sign the transaction through their Web3 wallet
+     *
+     * @throws {RunnerError} If transaction reverts or execution fails
+     */
+    async run() {
+        const safeTransaction = await this.getSafeTransaction();
+        const txResult = await this.safe.executeTransaction(safeTransaction);
+        if (!txResult.hash) {
+            throw RunnerError.executionFailed('No transaction hash returned from Safe execution');
+        }
+        // Wait for transaction receipt
+        const receipt = await this.publicClient.waitForTransactionReceipt({
+            hash: txResult.hash,
+        });
+        // Check transaction status and throw if reverted
+        if (receipt.status === 'reverted') {
+            throw RunnerError.transactionReverted(receipt.transactionHash, receipt.blockNumber, receipt.gasUsed);
+        }
+        // Return viem's TransactionReceipt directly
+        return receipt;
+    }
+}

package/dist/safe-runner.d.ts

@@ -0,0 +1,102 @@
+import type { Address, Hex, TransactionRequest } from '@aboutcircles/sdk-types';
+import type { ContractRunner, BatchRun } from './runner';
+import type { PublicClient, TransactionReceipt, Chain } from 'viem';
+/**
+ * Batch transaction runner for Safe
+ * Allows multiple transactions to be batched and executed together
+ */
+export declare class SafeBatchRun implements BatchRun {
+    private readonly safe;
+    private readonly publicClient;
+    private readonly transactions;
+    constructor(safe: any, publicClient: PublicClient);
+    /**
+     * Add a transaction to the batch
+     */
+    addTransaction(tx: TransactionRequest): void;
+    /**
+     * Get the Safe transaction data for all batched transactions
+     */
+    getSafeTransaction(): Promise<any>;
+    /**
+     * Execute all batched transactions and wait for confirmation
+     * @throws {RunnerError} If transaction reverts or execution fails
+     */
+    run(): Promise<TransactionReceipt>;
+}
+/**
+ * Safe contract runner implementation using Safe Protocol Kit
+ * Executes transactions through a Safe multisig wallet
+ */
+export declare class SafeContractRunner implements ContractRunner {
+    address?: Address;
+    publicClient: PublicClient;
+    private privateKey;
+    private rpcUrl;
+    private safeAddress?;
+    private safe?;
+    /**
+     * Creates a new SafeContractRunner
+     * @param publicClient - The viem public client for reading blockchain state
+     * @param privateKey - The private key of one of the Safe signers
+     * @param rpcUrl - The RPC URL to use for Safe operations
+     * @param safeAddress - The address of the Safe wallet (optional, can be set in init)
+     */
+    constructor(publicClient: PublicClient, privateKey: Hex, rpcUrl: string, safeAddress?: Address);
+    /**
+     * Create and initialize a SafeContractRunner in one step
+     * @param rpcUrl - The RPC URL to connect to
+     * @param privateKey - The private key of one of the Safe signers
+     * @param safeAddress - The address of the Safe wallet
+     * @param chain - The viem chain configuration (e.g., gnosis from 'viem/chains')
+     * @returns An initialized SafeContractRunner instance
+     *
+     * @example
+     * ```typescript
+     * import { gnosis } from 'viem/chains';
+     * import { SafeContractRunner } from '@aboutcircles/sdk-runner';
+     *
+     * const runner = await SafeContractRunner.create(
+     *   'https://rpc.gnosischain.com',
+     *   '0xYourPrivateKey...',
+     *   '0xYourSafeAddress...',
+     *   gnosis
+     * );
+     * ```
+     */
+    static create(rpcUrl: string, privateKey: Hex, safeAddress: Address, chain: Chain): Promise<SafeContractRunner>;
+    /**
+     * Initialize the runner with a Safe address
+     * @param safeAddress - The address of the Safe wallet (optional if provided in constructor)
+     */
+    init(safeAddress?: Address): Promise<void>;
+    /**
+     * Ensures the Safe is initialized
+     */
+    private ensureSafe;
+    /**
+     * Estimate gas for a transaction
+     */
+    estimateGas: (tx: TransactionRequest) => Promise<bigint>;
+    /**
+     * Call a contract (read-only operation)
+     */
+    call: (tx: TransactionRequest) => Promise<string>;
+    /**
+     * Resolve an ENS name to an address
+     */
+    resolveName: (name: string) => Promise<string | null>;
+    /**
+     * Send one or more transactions through the Safe and wait for confirmation
+     * All transactions are batched and executed atomically
+     *
+     * @throws {RunnerError} If transaction reverts or execution fails
+     */
+    sendTransaction: (txs: TransactionRequest[]) => Promise<TransactionReceipt>;
+    /**
+     * Create a batch transaction runner
+     * @returns A SafeBatchRun instance for batching multiple transactions
+     */
+    sendBatchTransaction: () => SafeBatchRun;
+}
+//# sourceMappingURL=safe-runner.d.ts.map

package/dist/safe-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-runner.d.ts","sourceRoot":"","sources":["../src/safe-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAYpE;;;GAGG;AACH,qBAAa,YAAa,YAAW,QAAQ;IAIzC,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAJ/B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA4B;gBAGtC,IAAI,EAAE,GAAG,EACT,YAAY,EAAE,YAAY;IAG7C;;OAEG;IACH,cAAc,CAAC,EAAE,EAAE,kBAAkB;IAIrC;;OAEG;IACG,kBAAkB;IAexB;;;OAGG;IACG,GAAG,IAAI,OAAO,CAAC,kBAAkB,CAAC;CA0BzC;AAED;;;GAGG;AACH,qBAAa,kBAAmB,YAAW,cAAc;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;IAElC,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,WAAW,CAAC,CAAU;IAC9B,OAAO,CAAC,IAAI,CAAC,CAAM;IAEnB;;;;;;OAMG;gBAGD,YAAY,EAAE,YAAY,EAC1B,UAAU,EAAE,GAAG,EACf,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,OAAO;IAQvB;;;;;;;;;;;;;;;;;;;;OAoBG;WACU,MAAM,CACjB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,GAAG,EACf,WAAW,EAAE,OAAO,EACpB,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,kBAAkB,CAAC;IAW9B;;;OAGG;IACG,IAAI,CAAC,WAAW,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBhD;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,WAAW,GAAU,IAAI,kBAAkB,KAAG,OAAO,CAAC,MAAM,CAAC,CAW3D;IAEF;;OAEG;IACH,IAAI,GAAU,IAAI,kBAAkB,KAAG,OAAO,CAAC,MAAM,CAAC,CAapD;IAEF;;OAEG;IACH,WAAW,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAUxD;IAEF;;;;;OAKG;IACH,eAAe,GAAU,KAAK,kBAAkB,EAAE,KAAG,OAAO,CAAC,kBAAkB,CAAC,CA0C9E;IAEF;;;OAGG;IACH,oBAAoB,QAAO,YAAY,CAGrC;CACH"}