@vultisig/rujira 1.0.0

package/dist/utils/cache.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Quote caching utility for reducing RPC calls
+ * @module utils/cache
+ */
+/**
+ * Cached item with TTL
+ */
+export type CachedItem<T> = {
+    value: T;
+    expiresAt: number;
+};
+/**
+ * Options for QuoteCache
+ */
+export type QuoteCacheOptions = {
+    /** Time-to-live in milliseconds (default: 10000 = 10 seconds) */
+    ttlMs?: number;
+    /** Maximum cache size (default: 100) */
+    maxSize?: number;
+};
+/**
+ * Simple TTL cache for swap quotes
+ *
+ * @example
+ * ```typescript
+ * const cache = new QuoteCache({ ttlMs: 10000 });
+ *
+ * // Store a quote
+ * cache.set('BTC.BTC', 'THOR.RUNE', '100000000', quote);
+ *
+ * // Retrieve if not expired
+ * const cached = cache.get('BTC.BTC', 'THOR.RUNE', '100000000');
+ * if (cached) {
+ *   return cached; // Cache hit
+ * }
+ * ```
+ */
+export declare class QuoteCache<T = unknown> {
+    private cache;
+    private readonly ttlMs;
+    private readonly maxSize;
+    constructor(options?: QuoteCacheOptions);
+    /**
+     * Generate cache key from quote parameters.
+     * Slippage is intentionally excluded - callers should compute
+     * slippage-dependent values (like minimumOutput) at retrieval time
+     * from the cached expectedOutput, not at storage time.
+     */
+    private makeKey;
+    /**
+     * Get cached value if not expired
+     */
+    get(fromAsset: string, toAsset: string, amount: string): T | null;
+    /**
+     * Store value in cache
+     */
+    set(fromAsset: string, toAsset: string, amount: string, value: T): void;
+    /**
+     * Check if cache has valid (non-expired) entry
+     */
+    has(fromAsset: string, toAsset: string, amount: string): boolean;
+    /**
+     * Invalidate a specific cache entry
+     */
+    invalidate(fromAsset: string, toAsset: string, amount: string): void;
+    /**
+     * Invalidate all entries for a trading pair
+     */
+    invalidatePair(fromAsset: string, toAsset: string): void;
+    /**
+     * Clear all cached entries
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    stats(): {
+        size: number;
+        maxSize: number;
+        ttlMs: number;
+    };
+    /**
+     * Prune expired entries (call periodically for long-running processes)
+     */
+    prune(): number;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/utils/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/utils/cache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,KAAK,EAAE,CAAC,CAAA;IACR,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,iEAAiE;IACjE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,UAAU,CAAC,CAAC,GAAG,OAAO;IACjC,OAAO,CAAC,KAAK,CAAmC;IAChD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;gBAEpB,OAAO,GAAE,iBAAsB;IAK3C;;;;;OAKG;IACH,OAAO,CAAC,OAAO;IAIf;;OAEG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI;IAiBjE;;OAEG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAiBvE;;OAEG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO;IAIhE;;OAEG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAKpE;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IASxD;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,KAAK,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE;IAQzD;;OAEG;IACH,KAAK,IAAI,MAAM;CAahB"}

package/dist/utils/cache.js

@@ -0,0 +1,124 @@
+/**
+ * Quote caching utility for reducing RPC calls
+ * @module utils/cache
+ */
+/**
+ * Simple TTL cache for swap quotes
+ *
+ * @example
+ * ```typescript
+ * const cache = new QuoteCache({ ttlMs: 10000 });
+ *
+ * // Store a quote
+ * cache.set('BTC.BTC', 'THOR.RUNE', '100000000', quote);
+ *
+ * // Retrieve if not expired
+ * const cached = cache.get('BTC.BTC', 'THOR.RUNE', '100000000');
+ * if (cached) {
+ *   return cached; // Cache hit
+ * }
+ * ```
+ */
+export class QuoteCache {
+    constructor(options = {}) {
+        this.cache = new Map();
+        this.ttlMs = options.ttlMs ?? 10000; // 10 seconds default
+        this.maxSize = options.maxSize ?? 100;
+    }
+    /**
+     * Generate cache key from quote parameters.
+     * Slippage is intentionally excluded - callers should compute
+     * slippage-dependent values (like minimumOutput) at retrieval time
+     * from the cached expectedOutput, not at storage time.
+     */
+    makeKey(fromAsset, toAsset, amount) {
+        return `${fromAsset}/${toAsset}/${amount}`;
+    }
+    /**
+     * Get cached value if not expired
+     */
+    get(fromAsset, toAsset, amount) {
+        const key = this.makeKey(fromAsset, toAsset, amount);
+        const cached = this.cache.get(key);
+        if (!cached) {
+            return null;
+        }
+        // Check expiry
+        if (Date.now() > cached.expiresAt) {
+            this.cache.delete(key);
+            return null;
+        }
+        return cached.value;
+    }
+    /**
+     * Store value in cache
+     */
+    set(fromAsset, toAsset, amount, value) {
+        const key = this.makeKey(fromAsset, toAsset, amount);
+        // Enforce max size (LRU-style: remove oldest entries)
+        if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, {
+            value,
+            expiresAt: Date.now() + this.ttlMs,
+        });
+    }
+    /**
+     * Check if cache has valid (non-expired) entry
+     */
+    has(fromAsset, toAsset, amount) {
+        return this.get(fromAsset, toAsset, amount) !== null;
+    }
+    /**
+     * Invalidate a specific cache entry
+     */
+    invalidate(fromAsset, toAsset, amount) {
+        const key = this.makeKey(fromAsset, toAsset, amount);
+        this.cache.delete(key);
+    }
+    /**
+     * Invalidate all entries for a trading pair
+     */
+    invalidatePair(fromAsset, toAsset) {
+        const prefix = `${fromAsset}/${toAsset}/`;
+        for (const key of this.cache.keys()) {
+            if (key.startsWith(prefix)) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+     * Clear all cached entries
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache statistics
+     */
+    stats() {
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            ttlMs: this.ttlMs,
+        };
+    }
+    /**
+     * Prune expired entries (call periodically for long-running processes)
+     */
+    prune() {
+        const now = Date.now();
+        let pruned = 0;
+        for (const [key, item] of this.cache.entries()) {
+            if (now > item.expiresAt) {
+                this.cache.delete(key);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+}

package/dist/utils/denom-conversion.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Canonical denom-to-ticker and denom-to-asset conversion
+ * @module utils/denom-conversion
+ */
+/**
+ * Convert a denom (any format) to a short ticker for display.
+ *
+ * Resolution order:
+ * 1. Look up via findAssetByFormat (handles thorchain, fin, l1 formats)
+ * 2. Iterate KNOWN_ASSETS checking fin format (catches cases where denom is a raw fin string)
+ * 3. Parse denom string (chain-symbol → SYMBOL)
+ *
+ * @param denom - Denom string in any format
+ * @returns Short ticker (e.g., "BTC", "USDC", "RUNE")
+ */
+export declare function denomToTicker(denom: string): string;
+/**
+ * Convert a denom to a THORChain asset identifier (e.g., "BTC.BTC").
+ *
+ * Resolution order:
+ * 1. Look up via findAssetByFormat → return thorchain format
+ * 2. Reverse-engineer from denom format (chain-symbol → CHAIN.SYMBOL)
+ *
+ * @param denom - Denom string in any format
+ * @returns THORChain asset string or null if unresolvable
+ */
+export declare function denomToAsset(denom: string): string | null;
+/**
+ * Extract a display symbol from an asset string or denom.
+ *
+ * @param assetOrDenom - Asset string (e.g., "ETH.USDC-0X...") or denom
+ * @returns Symbol (e.g., "USDC")
+ */
+export declare function extractSymbol(assetOrDenom: string): string;
+/**
+ * Parse a THORChain asset string into its components.
+ *
+ * @param asset - Asset string (e.g., "ETH.USDC-0XA0B86991...")
+ * @returns Parsed components
+ */
+export declare function parseAsset(asset: string): {
+    chain: string;
+    symbol: string;
+    ticker: string;
+    contractAddress?: string;
+};
+//# sourceMappingURL=denom-conversion.d.ts.map

package/dist/utils/denom-conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"denom-conversion.d.ts","sourceRoot":"","sources":["../../src/utils/denom-conversion.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAqBnD;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAkBzD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAkB1D;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG;IACzC,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAcA"}

package/dist/utils/denom-conversion.js

@@ -0,0 +1,105 @@
+/**
+ * Canonical denom-to-ticker and denom-to-asset conversion
+ * @module utils/denom-conversion
+ */
+import { findAssetByFormat, KNOWN_ASSETS } from '../assets/index.js';
+/**
+ * Convert a denom (any format) to a short ticker for display.
+ *
+ * Resolution order:
+ * 1. Look up via findAssetByFormat (handles thorchain, fin, l1 formats)
+ * 2. Iterate KNOWN_ASSETS checking fin format (catches cases where denom is a raw fin string)
+ * 3. Parse denom string (chain-symbol → SYMBOL)
+ *
+ * @param denom - Denom string in any format
+ * @returns Short ticker (e.g., "BTC", "USDC", "RUNE")
+ */
+export function denomToTicker(denom) {
+    // 1. Try findAssetByFormat (handles all known formats)
+    const asset = findAssetByFormat(denom);
+    if (asset) {
+        return asset.id.toUpperCase();
+    }
+    // 2. Try matching fin format directly against known assets
+    for (const knownAsset of Object.values(KNOWN_ASSETS)) {
+        if (knownAsset.formats.fin === denom) {
+            return knownAsset.name.split(' ')[0].toUpperCase();
+        }
+    }
+    // 3. Parse denom string
+    const parts = denom.split('-');
+    if (parts.length >= 2) {
+        return (parts[1] || '').toUpperCase();
+    }
+    return denom.toUpperCase();
+}
+/**
+ * Convert a denom to a THORChain asset identifier (e.g., "BTC.BTC").
+ *
+ * Resolution order:
+ * 1. Look up via findAssetByFormat → return thorchain format
+ * 2. Reverse-engineer from denom format (chain-symbol → CHAIN.SYMBOL)
+ *
+ * @param denom - Denom string in any format
+ * @returns THORChain asset string or null if unresolvable
+ */
+export function denomToAsset(denom) {
+    // 1. Look up in asset registry
+    const asset = findAssetByFormat(denom);
+    if (asset) {
+        return asset.formats.thorchain;
+    }
+    // 2. Reverse-engineer from denom format: btc-btc -> BTC.BTC
+    if (denom.includes('-')) {
+        const parts = denom.split('-');
+        if (parts.length >= 2) {
+            const chain = (parts[0] || '').toUpperCase();
+            const symbol = parts.slice(1).join('-').toUpperCase();
+            return `${chain}.${symbol}`;
+        }
+    }
+    return null;
+}
+/**
+ * Extract a display symbol from an asset string or denom.
+ *
+ * @param assetOrDenom - Asset string (e.g., "ETH.USDC-0X...") or denom
+ * @returns Symbol (e.g., "USDC")
+ */
+export function extractSymbol(assetOrDenom) {
+    // Handle full asset format: ETH.USDC-0X... -> USDC
+    if (assetOrDenom.includes('.')) {
+        const afterDot = assetOrDenom.split('.')[1] || '';
+        const symbol = afterDot.split('-')[0] || '';
+        return symbol.toUpperCase();
+    }
+    // Handle denom format: eth-usdc-0x... -> USDC
+    if (assetOrDenom.includes('-')) {
+        const parts = assetOrDenom.split('-');
+        if (parts.length >= 2) {
+            return (parts[1] || '').toUpperCase();
+        }
+    }
+    // Simple case: rune -> RUNE
+    return assetOrDenom.toUpperCase();
+}
+/**
+ * Parse a THORChain asset string into its components.
+ *
+ * @param asset - Asset string (e.g., "ETH.USDC-0XA0B86991...")
+ * @returns Parsed components
+ */
+export function parseAsset(asset) {
+    const parts = asset.split('.');
+    const chain = (parts[0] || '').toUpperCase();
+    const rest = parts.slice(1).join('.') || '';
+    const symbolParts = rest.split('-');
+    const ticker = symbolParts[0] || '';
+    const contractAddress = symbolParts[1];
+    return {
+        chain,
+        symbol: rest,
+        ticker,
+        contractAddress: contractAddress ? `0x${contractAddress.replace(/^0[xX]/, '')}` : undefined,
+    };
+}

package/dist/utils/encoding.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Cross-platform encoding helpers (Node.js + browser)
+ * @module utils/encoding
+ */
+/** Encode a UTF-8 string to base64. */
+export declare function base64Encode(input: string): string;
+/** Decode a base64 string to UTF-8. */
+export declare function base64Decode(input: string): string;
+/** Encode a Uint8Array to a hex string (no 0x prefix). */
+export declare function hexEncode(bytes: Uint8Array): string;
+/** Decode a hex string (with or without 0x prefix) to Uint8Array. */
+export declare function hexDecode(hex: string): Uint8Array;
+/** Encode a Uint8Array to base64. */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/** Encode a UTF-8 string to Uint8Array. */
+export declare function stringToBytes(str: string): Uint8Array;
+//# sourceMappingURL=encoding.d.ts.map

package/dist/utils/encoding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.d.ts","sourceRoot":"","sources":["../../src/utils/encoding.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,uCAAuC;AACvC,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKlD;AAED,uCAAuC;AACvC,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKlD;AAED,0DAA0D;AAC1D,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAKnD;AAED,qEAAqE;AACrE,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAajD;AAED,qCAAqC;AACrC,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAKvD;AAED,2CAA2C;AAC3C,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAKrD"}

package/dist/utils/encoding.js

@@ -0,0 +1,55 @@
+/**
+ * Cross-platform encoding helpers (Node.js + browser)
+ * @module utils/encoding
+ */
+const hasBuffer = typeof globalThis.Buffer !== 'undefined';
+/** Encode a UTF-8 string to base64. */
+export function base64Encode(input) {
+    if (hasBuffer) {
+        return globalThis.Buffer.from(input).toString('base64');
+    }
+    return btoa(Array.from(new TextEncoder().encode(input), b => String.fromCharCode(b)).join(''));
+}
+/** Decode a base64 string to UTF-8. */
+export function base64Decode(input) {
+    if (hasBuffer) {
+        return globalThis.Buffer.from(input, 'base64').toString();
+    }
+    return new TextDecoder().decode(Uint8Array.from(atob(input), c => c.charCodeAt(0)));
+}
+/** Encode a Uint8Array to a hex string (no 0x prefix). */
+export function hexEncode(bytes) {
+    if (hasBuffer) {
+        return globalThis.Buffer.from(bytes).toString('hex');
+    }
+    return Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
+}
+/** Decode a hex string (with or without 0x prefix) to Uint8Array. */
+export function hexDecode(hex) {
+    const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (clean.length % 2 !== 0) {
+        throw new Error('Hex string must have even length');
+    }
+    if (!/^[0-9a-fA-F]*$/.test(clean)) {
+        throw new Error('Hex string contains non-hex characters');
+    }
+    const bytes = new Uint8Array(clean.length / 2);
+    for (let i = 0; i < clean.length; i += 2) {
+        bytes[i / 2] = parseInt(clean.slice(i, i + 2), 16);
+    }
+    return bytes;
+}
+/** Encode a Uint8Array to base64. */
+export function bytesToBase64(bytes) {
+    if (hasBuffer) {
+        return globalThis.Buffer.from(bytes).toString('base64');
+    }
+    return btoa(Array.from(bytes, b => String.fromCharCode(b)).join(''));
+}
+/** Encode a UTF-8 string to Uint8Array. */
+export function stringToBytes(str) {
+    if (hasBuffer) {
+        return new Uint8Array(globalThis.Buffer.from(str));
+    }
+    return new TextEncoder().encode(str);
+}

package/dist/utils/format.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Formatting utilities for Rujira SDK
+ * @module utils/format
+ */
+import type { SwapRequest } from '../types.js';
+/**
+ * Convert human-readable amount to base units
+ *
+ * @param amount - Human readable amount (e.g., "1.5")
+ * @param decimals - Number of decimals
+ * @returns Base units as string
+ *
+ * @example
+ * ```typescript
+ * toBaseUnits("1.5", 8); // "150000000"
+ * toBaseUnits("0.001", 18); // "1000000000000000"
+ * ```
+ */
+export declare function toBaseUnits(amount: string | number, decimals: number): string;
+/**
+ * Convert base units to human-readable amount
+ *
+ * @param baseUnits - Amount in base units
+ * @param decimals - Number of decimals
+ * @returns Human readable amount
+ *
+ * @example
+ * ```typescript
+ * fromBaseUnits("150000000", 8); // "1.5"
+ * fromBaseUnits("1000000000000000", 18); // "0.001"
+ * ```
+ */
+export declare function fromBaseUnits(baseUnits: string | bigint, decimals: number): string;
+/**
+ * Format amount for display (truncates fractional digits).
+ * For fee displays where underestimation is harmful, use {@link formatFee} instead.
+ *
+ * @param baseUnits - Amount in base units
+ * @param asset - Asset identifier (any format recognized by the asset registry)
+ * @param maxDecimals - Maximum decimal places to show
+ */
+export declare function formatAmount(baseUnits: string | bigint, asset: string, maxDecimals?: number): string;
+/**
+ * Format fee amount for display (rounds UP to avoid underestimating costs).
+ * Use this for fee/gas displays where showing less than actual is misleading.
+ *
+ * @param baseUnits - Amount in base units
+ * @param asset - Asset identifier (any format recognized by the asset registry)
+ * @param maxDecimals - Maximum decimal places to show
+ */
+export declare function formatFee(baseUnits: string | bigint, asset: string, maxDecimals?: number): string;
+/**
+ * Calculate minimum return after slippage
+ *
+ * @param expectedOutput - Expected output in base units
+ * @param slippageBps - Slippage tolerance in basis points
+ * @returns Minimum acceptable output
+ */
+export declare function calculateMinReturn(expectedOutput: string | bigint, slippageBps: number): string;
+/**
+ * Calculate slippage percentage from expected vs actual
+ *
+ * @param expected - Expected amount
+ * @param actual - Actual amount received
+ * @returns Slippage percentage (negative if worse than expected)
+ */
+export declare function calculateSlippage(expected: string | bigint, actual: string | bigint): string;
+/**
+ * Generate a unique quote ID using cryptographic randomness.
+ */
+export declare function generateQuoteId(): string;
+/**
+ * Build a swap message from parameters
+ *
+ * @param minReturn - Minimum return amount
+ * @param to - Destination address (optional)
+ */
+export declare function buildSwapMsg(minReturn: string, to?: string): {
+    swap: SwapRequest;
+};
+/**
+ * Truncate string in the middle (for addresses)
+ *
+ * @param str - String to truncate
+ * @param startChars - Characters to show at start
+ * @param endChars - Characters to show at end
+ */
+export declare function truncateMiddle(str: string, startChars?: number, endChars?: number): string;
+/**
+ * Format percentage for display
+ *
+ * @param value - Decimal value (e.g., 0.015 for 1.5%)
+ * @param decimals - Decimal places to show
+ */
+export declare function formatPercentage(value: number | string, decimals?: number): string;
+/**
+ * Format basis points as percentage
+ *
+ * @param bps - Basis points
+ */
+export declare function bpsToPercent(bps: number): string;
+/**
+ * Convert percentage to basis points
+ *
+ * @param percent - Percentage (e.g., 1.5 for 1.5%)
+ */
+export declare function percentToBps(percent: number): number;
+//# sourceMappingURL=format.d.ts.map

package/dist/utils/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/utils/format.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE9C;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAW7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAOlF;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,SAAI,GAAG,MAAM,CAkB/F;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,SAAI,GAAG,MAAM,CA0C5F;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAI/F;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAU5F;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAUxC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CASlF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,SAAI,EAAE,QAAQ,SAAI,GAAG,MAAM,CAKhF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,SAAI,GAAG,MAAM,CAG7E;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpD"}