@gala-chain/launchpad-sdk 6.0.0 → 7.0.0-beta.2

package/dist/utils/position-filters.d.ts

@@ -1,252 +0,0 @@
-/**
- * Liquidity position filter utilities
- *
- * Helper functions for filtering and grouping liquidity positions by various criteria:
- * - Liquidity amount and thresholds
- * - Token pairs and individual tokens
- * - Fee tiers
- * - Pool identifiers (token0|token1|feeTier)
- *
- * All functions are pure and return new arrays/maps without mutating input.
- *
- * @example
- * ```typescript
- * import { filterByLiquidity, groupByTokenPair } from '@gala-chain/launchpad-sdk';
- *
- * const positions = await sdk.getAllSwapUserLiquidityPositions(address);
- * const active = filterByLiquidity(positions);  // Remove zero-liquidity positions
- * const grouped = groupByTokenPair(active);     // Organize by GALA/GUSDC, etc.
- * ```
- */
-import type { LiquidityPosition } from '../types/gswap.dto';
-/**
- * Sort order for position arrays
- */
-export type SortOrder = 'asc' | 'desc';
-/**
- * Predicate function for filtering positions
- */
-export type PositionFilter = (position: LiquidityPosition) => boolean;
-/**
- * Options for position filtering operations
- */
-export interface PositionFilterOptions {
-    /** Minimum liquidity threshold */
-    minLiquidity?: string;
-    /** Fee tier to filter by (500, 3000, or 10000) */
-    feeTier?: number;
-    /** Token symbol to filter by (either token0 or token1) */
-    token?: string;
-}
-/**
- * Filter positions to only those with non-zero liquidity
- *
- * Removes positions with `liquidity === '0'`, typically indicating
- * closed or inactive positions.
- *
- * @param positions Array of liquidity positions
- * @returns Filtered array with only positions that have liquidity > 0
- *
- * @example
- * ```typescript
- * const allPositions = await sdk.getAllSwapUserLiquidityPositions(address);
- * const activePositions = filterByLiquidity(allPositions);
- * console.log(`Active positions: ${activePositions.length}`);
- * ```
- */
-export declare function filterByLiquidity(positions: LiquidityPosition[]): LiquidityPosition[];
-/**
- * Filter positions by minimum liquidity threshold
- *
- * Keeps only positions with `liquidity >= minLiquidity`. Useful for
- * finding significant positions or filtering out dust positions.
- *
- * @param positions Array of liquidity positions
- * @param minLiquidity Minimum liquidity amount (as string for precision)
- * @returns Filtered array with positions >= minLiquidity
- *
- * @example
- * ```typescript
- * const largePositions = filterByMinLiquidity(positions, '1000');
- * // Only positions with liquidity >= 1000
- *
- * const hugePositions = filterByMinLiquidity(positions, '100000');
- * // Find whale positions
- * ```
- */
-export declare function filterByMinLiquidity(positions: LiquidityPosition[], minLiquidity: string | number): LiquidityPosition[];
-/**
- * Sort positions by liquidity amount
- *
- * @param positions Array of liquidity positions
- * @param order Sort order: 'desc' (default, highest first) or 'asc' (lowest first)
- * @returns Sorted array (creates new array, doesn't mutate input)
- *
- * @example
- * ```typescript
- * const sorted = sortByLiquidity(positions, 'desc');
- * const topPosition = sorted[0];  // Largest liquidity position
- *
- * const lowest = sortByLiquidity(positions, 'asc');
- * const smallest = lowest[0];    // Smallest liquidity position
- * ```
- */
-export declare function sortByLiquidity(positions: LiquidityPosition[], order?: SortOrder): LiquidityPosition[];
-/**
- * Filter positions by exact token pair match
- *
- * Matches token0 and token1 in either order. Comparison is case-insensitive.
- *
- * @param positions Array of liquidity positions
- * @param token0 First token symbol (e.g., "GALA")
- * @param token1 Second token symbol (e.g., "GUSDC")
- * @returns Positions matching the token pair
- *
- * @example
- * ```typescript
- * const galaPositions = filterByTokenPair(positions, 'GALA', 'GUSDC');
- * // Returns positions for GALA/GUSDC pair (in either order)
- *
- * const reverseMatch = filterByTokenPair(positions, 'GUSDC', 'GALA');
- * // Also returns GALA/GUSDC positions (same result as above)
- * ```
- */
-export declare function filterByTokenPair(positions: LiquidityPosition[], token0: string, token1: string): LiquidityPosition[];
-/**
- * Filter positions by a single token (either side of the pair)
- *
- * Finds all positions where the token appears as either token0 or token1.
- * Comparison is case-insensitive.
- *
- * @param positions Array of liquidity positions
- * @param token Token symbol to search for (e.g., "GALA")
- * @returns Positions containing the specified token
- *
- * @example
- * ```typescript
- * const galaPositions = filterByToken(positions, 'GALA');
- * // Returns GALA/GUSDC, GALA/ETH, ETH/GALA, etc.
- *
- * const stablecoinPositions = filterByToken(positions, 'GUSDC');
- * // Any position with GUSDC on either side
- * ```
- */
-export declare function filterByToken(positions: LiquidityPosition[], token: string): LiquidityPosition[];
-/**
- * Filter positions by fee tier
- *
- * Finds positions using a specific fee tier (0.05%, 0.30%, or 1.00%).
- *
- * @param positions Array of liquidity positions
- * @param feeTier Fee tier in basis points (500 = 0.05%, 3000 = 0.30%, 10000 = 1.00%)
- * @returns Positions with the specified fee tier
- *
- * @example
- * ```typescript
- * const lowFee = filterByFeeTier(positions, 500);     // 0.05% - Best for stablecoins
- * const mid = filterByFeeTier(positions, 3000);       // 0.30% - Standard
- * const highFee = filterByFeeTier(positions, 10000);  // 1.00% - Volatile pairs
- * ```
- */
-export declare function filterByFeeTier(positions: LiquidityPosition[], feeTier: number): LiquidityPosition[];
-/**
- * Group positions by token pair
- *
- * Creates a Map keyed by "TOKEN0/TOKEN1" containing arrays of positions
- * for that pair. The pair key format is always uppercase with "/" separator.
- *
- * @param positions Array of liquidity positions
- * @returns Map<pair_string, positions[]> where pair_string is "TOKEN0/TOKEN1"
- *
- * @example
- * ```typescript
- * const grouped = groupByTokenPair(positions);
- *
- * // Access positions for specific pairs
- * const galusdcPos = grouped.get('GALA/GUSDC');
- * const galaethPos = grouped.get('GALA/ETH');
- *
- * // Iterate over all pairs
- * grouped.forEach((positions, pair) => {
- *   console.log(`${pair}: ${positions.length} positions`);
- * });
- * ```
- */
-export declare function groupByTokenPair(positions: LiquidityPosition[]): Map<string, LiquidityPosition[]>;
-/**
- * Group positions by fee tier
- *
- * Creates a Map keyed by fee tier (500, 3000, 10000) containing arrays
- * of positions using that fee tier.
- *
- * @param positions Array of liquidity positions
- * @returns Map<feeTier, positions[]>
- *
- * @example
- * ```typescript
- * const byFee = groupByFeeTier(positions);
- *
- * const stablecoinPos = byFee.get(500);   // 0.05% fee tier
- * const standardPos = byFee.get(3000);    // 0.30% fee tier
- * const volatilePos = byFee.get(10000);   // 1.00% fee tier
- *
- * // Fee tier statistics
- * byFee.forEach((positions, feeTier) => {
- *   const feePercent = feeTier / 100;
- *   console.log(`${feePercent}%: ${positions.length} positions`);
- * });
- * ```
- */
-export declare function groupByFeeTier(positions: LiquidityPosition[]): Map<number, LiquidityPosition[]>;
-/**
- * Filter positions by complete pool identifier
- *
- * Matches positions that belong to a specific pool identified by
- * token0, token1, and fee tier. Comparison is case-insensitive for tokens.
- *
- * @param positions Array of liquidity positions
- * @param token0 First token symbol
- * @param token1 Second token symbol
- * @param feeTier Fee tier (500, 3000, or 10000)
- * @returns Positions matching the specific pool
- *
- * @example
- * ```typescript
- * // Find all positions in the GALA/GUSDC 0.30% pool
- * const poolPositions = filterByPoolKey(positions, 'GALA', 'GUSDC', 3000);
- *
- * // Calculate total liquidity in a specific pool
- * const totalLiq = poolPositions
- *   .reduce((sum, pos) => sum + BigInt(pos.liquidity), 0n);
- * ```
- */
-export declare function filterByPoolKey(positions: LiquidityPosition[], token0: string, token1: string, feeTier: number): LiquidityPosition[];
-/**
- * Group positions by pool identifier (token pair + fee tier)
- *
- * Creates a Map keyed by "token0|token1|feeTier" containing arrays of
- * positions in that specific pool. Useful for analyzing pool-specific metrics.
- *
- * @param positions Array of liquidity positions
- * @returns Map<pool_key, positions[]> where pool_key is "TOKEN0|TOKEN1|FEETIER"
- *
- * @example
- * ```typescript
- * const byPool = groupByPoolKey(positions);
- *
- * // Access positions in specific pool
- * const galusdcStandard = byPool.get('GALA|GUSDC|3000');
- *
- * // Calculate pool statistics
- * byPool.forEach((positions, poolKey) => {
- *   const [token0, token1, feeTier] = poolKey.split('|');
- *   const total = positions.reduce(
- *     (sum, pos) => sum.plus(pos.liquidity),
- *     new BigNumber(0)
- *   );
- *   console.log(`${poolKey}: ${positions.length} LPs, ${total} total liquidity`);
- * });
- * ```
- */
-export declare function groupByPoolKey(positions: LiquidityPosition[]): Map<string, LiquidityPosition[]>;
-//# sourceMappingURL=position-filters.d.ts.map

package/dist/utils/position-filters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"position-filters.d.ts","sourceRoot":"","sources":["../../src/utils/position-filters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAK5D;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;AAEvC;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,QAAQ,EAAE,iBAAiB,KAAK,OAAO,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,kCAAkC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,iBAAiB,EAAE,CAErF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,iBAAiB,EAAE,EAC9B,YAAY,EAAE,MAAM,GAAG,MAAM,GAC5B,iBAAiB,EAAE,CAGrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,KAAK,GAAE,SAAkB,GACxB,iBAAiB,EAAE,CAOrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,iBAAiB,EAAE,CASrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,iBAAiB,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAIhG;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,OAAO,EAAE,MAAM,GACd,iBAAiB,EAAE,CAErB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAKjG;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAE/F;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,iBAAiB,EAAE,CAUrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAK/F"}

package/dist/utils/swap-delta-calculator.d.ts

@@ -1,231 +0,0 @@
-/**
- * Swap Delta Calculator
- *
- * Pure math functions that calculate how a swap affects pool state.
- * Implements Uniswap V3 concentrated liquidity swap mechanics with tick crossing.
- *
- * This is a CALCULATION-ONLY utility with NO state management.
- * All functions are pure and return new objects without mutating inputs.
- *
- * @packageDocumentation
- */
-import type { Pool, TickData } from '@gala-chain/dex';
-import BigNumber from 'bignumber.js';
-import type { CompositePoolDataResult } from '../types/composite-pool.dto';
-import type { InternalSwapState, SwapDeltaResult, SwapEventData } from '../types/pool-state-delta.dto';
-/**
- * Configuration for swap calculation behavior
- *
- * @category Pool State
- */
-export interface SwapCalculationConfig {
-    /** Safety limit for maximum swap iterations (default: 100) */
-    maxIterations: number;
-    /** Use BigNumber cache for performance (default: true) */
-    enableBigNumberCache: boolean;
-    /** BigNumber rounding mode (default: ROUND_DOWN) */
-    roundingMode: BigNumber.RoundingMode;
-    /** Enable debug logging for swap calculations (default: false) */
-    debugLogging: boolean;
-}
-/**
- * Result of the iterative swap loop calculation
- *
- * @internal
- */
-interface SwapLoopResult {
-    /** Final internal state after all iterations */
-    state: InternalSwapState;
-    /** Array of tick indices that were crossed during the swap */
-    ticksCrossed: number[];
-    /** True if price reached limit before consuming all input */
-    priceHitLimit: boolean;
-    /** Number of iterations executed */
-    stepCount: number;
-    /** Updated tick data map (only changed ticks) */
-    updatedTicks: Record<string, TickData>;
-}
-/**
- * Core swap calculation engine for applying swap deltas to pool state
- *
- * Implements Uniswap V3 concentrated liquidity mechanics:
- * - Iterative swap execution across tick boundaries
- * - Dynamic liquidity tracking as price crosses initialized ticks
- * - Fee accumulation and protocol fee calculation
- * - Exact input vs exact output handling
- *
- * @category Pool State
- * @since 3.33.0
- */
-export declare class SwapDeltaCalculator {
-    private static readonly logger;
-    /**
-     * Apply a single swap event to pool state
-     *
-     * Calculates new sqrtPrice, liquidity, tick, fees by simulating the swap execution.
-     * Returns complete updated state without modifying input poolData.
-     *
-     * **Performance**: 25-50ms for typical swaps (1-3 tick crossings)
-     *
-     * @param poolData Current composite pool data (not modified)
-     * @param swapEvent The swap to apply
-     * @param config Optional calculation configuration
-     * @returns Complete result with updated state and metadata
-     * @throws Error if swap calculation fails or pool data is invalid
-     *
-     * @example Simple swap calculation
-     * ```typescript
-     * const result = SwapDeltaCalculator.calculateSwapDelta(
-     *   compositePoolData,
-     *   {
-     *     transactionId: 'tx-123',
-     *     timestamp: Date.now(),
-     *     amountSpecified: '1000000000',
-     *     zeroForOne: true,
-     *     exactInput: true,
-     *   }
-     * );
-     *
-     * console.log(`New price: ${result.updatedPool.sqrtPrice}`);
-     * console.log(`Ticks crossed: ${result.ticksCrossed.length}`);
-     * console.log(`Amount0: ${result.amount0.toString()}`);
-     * console.log(`Amount1: ${result.amount1.toString()}`);
-     * ```
-     *
-     * @example With validation data
-     * ```typescript
-     * const result = SwapDeltaCalculator.calculateSwapDelta(
-     *   compositePoolData,
-     *   {
-     *     transactionId: 'tx-456',
-     *     timestamp: Date.now(),
-     *     amountSpecified: '5000000000',
-     *     zeroForOne: false,
-     *     exactInput: true,
-     *     actualAmount0: '4950000000',
-     *     actualAmount1: '-5000000000',
-     *     actualSqrtPrice: '79228162514264337593543950336',
-     *   }
-     * );
-     *
-     * if (result.metadata.driftPercentage) {
-     *   console.log(`Drift: ${result.metadata.driftPercentage.toFixed(4)}%`);
-     * }
-     * ```
-     */
-    static calculateSwapDelta(poolData: CompositePoolDataResult, swapEvent: SwapEventData, config?: Partial<SwapCalculationConfig>): SwapDeltaResult;
-    /**
-     * Initialize swap state from pool data and swap event
-     *
-     * Sets up the initial state for iterative swap calculation including:
-     * - Current price, liquidity, and tick
-     * - Amount remaining to swap
-     * - Fee growth and protocol fee accumulators
-     *
-     * @param poolData Current pool state
-     * @param swapEvent Swap event to process
-     * @param config Calculation configuration
-     * @returns Initialized swap state ready for loop execution
-     * @throws Error if pool data is invalid or inconsistent
-     *
-     * @internal
-     */
-    static initializeSwapState(poolData: CompositePoolDataResult, swapEvent: SwapEventData, config: SwapCalculationConfig): InternalSwapState;
-    /**
-     * Main iterative swap calculation loop
-     *
-     * Executes swap step-by-step, crossing tick boundaries as needed.
-     * Implements Uniswap V3 concentrated liquidity mechanics:
-     *
-     * 1. Find next initialized tick in swap direction
-     * 2. Calculate swap step to that tick boundary
-     * 3. Update state accumulators (amount, fees)
-     * 4. Handle tick crossing (liquidity changes)
-     * 5. Repeat until amount consumed or price limit reached
-     *
-     * **Performance**: 20-40ms for typical swaps (1-3 iterations)
-     *
-     * @param state Initial swap state to mutate during loop
-     * @param poolData Pool and tick data
-     * @param swapEvent Original swap information
-     * @param config Calculation configuration
-     * @returns Loop result with final state and metadata
-     * @throws Error if swap exceeds iteration limit or encounters invalid state
-     *
-     * @internal
-     */
-    static computeSwapLoop(state: InternalSwapState, poolData: CompositePoolDataResult, swapEvent: SwapEventData, config: SwapCalculationConfig): SwapLoopResult;
-    /**
-     * Create updated pool object with new state
-     *
-     * Returns a new Pool instance with updated sqrtPrice, liquidity, tick, and fees.
-     * Does NOT mutate the original pool object.
-     *
-     * @param originalPool Original pool state
-     * @param newState Updated swap state
-     * @param swapEvent Swap event that was applied
-     * @param config Calculation configuration
-     * @returns New Pool instance with updated state
-     *
-     * @internal
-     */
-    static createUpdatedPool(originalPool: Pool, newState: InternalSwapState, swapEvent: SwapEventData, _config: SwapCalculationConfig): Pool;
-    /**
-     * Calculate final token amounts from swap state
-     *
-     * Determines amount0 and amount1 based on swap direction and type (exact input vs exact output).
-     * Calculates fee amounts for each token.
-     *
-     * @param initialState State before swap
-     * @param finalState State after swap
-     * @param swapEvent Swap event details
-     * @returns Token amounts and fees (signed: negative = spent, positive = received)
-     *
-     * @internal
-     */
-    static calculateFinalAmounts(initialState: InternalSwapState, finalState: InternalSwapState, swapEvent: SwapEventData): {
-        amount0: BigNumber;
-        amount1: BigNumber;
-        feeAmount0: BigNumber;
-        feeAmount1: BigNumber;
-    };
-    /**
-     * Find next initialized tick in swap direction
-     *
-     * Scans tick data map to find the nearest initialized tick boundary.
-     * Uses pool's tick spacing to determine valid tick indices.
-     *
-     * @param tickDataMap Map of initialized ticks
-     * @param currentTick Current tick index
-     * @param tickSpacing Pool's tick spacing (e.g., 60 for 0.3% fee tier)
-     * @param zeroForOne Swap direction (true = decreasing price)
-     * @returns [nextTick, initialized] tuple
-     *
-     * @internal
-     */
-    private static findNextInitializedTick;
-    /**
-     * Execute a single swap step calculation
-     *
-     * Uses the production-ready Uniswap V3 swap math from @gala-chain/dex.
-     * Implements accurate constant-product pricing, fee calculations, and tick boundary handling.
-     *
-     * @param sqrtPriceCurrent Current sqrt price before swap
-     * @param sqrtPriceTarget Target sqrt price (next tick boundary or price limit)
-     * @param liquidity Active liquidity in current price range
-     * @param amountRemaining Tokens remaining to swap (positive value)
-     * @param feeTier Fee tier in basis points (3000 = 0.3%, 10000 = 1%)
-     * @param exactInput true=exact input amount, false=exact output amount
-     * @returns SwapStepResult with sqrtPriceNext, amountIn, amountOut, feeAmount
-     * @throws Error on invalid inputs or calculation failures
-     *
-     * @internal
-     */
-    private static executeSwapStep;
-}
-/**
- * Default export for convenience
- * @see {@link SwapDeltaCalculator}
- */
-export default SwapDeltaCalculator;
-//# sourceMappingURL=swap-delta-calculator.d.ts.map

package/dist/utils/swap-delta-calculator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"swap-delta-calculator.d.ts","sourceRoot":"","sources":["../../src/utils/swap-delta-calculator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAC3E,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,aAAa,EAEd,MAAM,+BAA+B,CAAC;AAgBvC;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,8DAA8D;IAC9D,aAAa,EAAE,MAAM,CAAC;IAEtB,0DAA0D;IAC1D,oBAAoB,EAAE,OAAO,CAAC;IAE9B,oDAAoD;IACpD,YAAY,EAAE,SAAS,CAAC,YAAY,CAAC;IAErC,kEAAkE;IAClE,YAAY,EAAE,OAAO,CAAC;CACvB;AAYD;;;;GAIG;AACH,UAAU,cAAc;IACtB,gDAAgD;IAChD,KAAK,EAAE,iBAAiB,CAAC;IAEzB,8DAA8D;IAC9D,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB,6DAA6D;IAC7D,aAAa,EAAE,OAAO,CAAC;IAEvB,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAC;IAElB,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAG3B;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqDG;IACH,MAAM,CAAC,kBAAkB,CACvB,QAAQ,EAAE,uBAAuB,EACjC,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,OAAO,CAAC,qBAAqB,CAAM,GAC1C,eAAe;IA4GlB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,mBAAmB,CACxB,QAAQ,EAAE,uBAAuB,EACjC,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,qBAAqB,GAC5B,iBAAiB;IAmEpB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,eAAe,CACpB,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,uBAAuB,EACjC,SAAS,EAAE,aAAa,EACxB,MAAM,EAAE,qBAAqB,GAC5B,cAAc;IAiKjB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,iBAAiB,CACtB,YAAY,EAAE,IAAI,EAClB,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,qBAAqB,GAC7B,IAAI;IA4BP;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,qBAAqB,CAC1B,YAAY,EAAE,iBAAiB,EAC/B,UAAU,EAAE,iBAAiB,EAC7B,SAAS,EAAE,aAAa,GACvB;QACD,OAAO,EAAE,SAAS,CAAC;QACnB,OAAO,EAAE,SAAS,CAAC;QACnB,UAAU,EAAE,SAAS,CAAC;QACtB,UAAU,EAAE,SAAS,CAAC;KACvB;IAyDD;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,MAAM,CAAC,uBAAuB;IA0CtC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;CAqE/B;AAED;;;GAGG;AACH,eAAe,mBAAmB,CAAC"}