@olane/o-node 0.7.12-alpha.42 → 0.7.12-alpha.43

package/dist/o-node/src/router/resolvers/o-node.search-resolver.js

@@ -1,285 +0,0 @@
-import { NodeState, oAddress, oAddressResolver, oCustomTransport, RestrictedAddresses, } from '@olane/o-core';
-import { oNodeTransport } from '../o-node.transport.js';
-/**
- * Address resolver that searches a registry to find transports for addresses.
- *
- * This resolver queries a registry service to find the transport information
- * for addresses that don't already have transports configured. It's designed
- * to be extensible through subclassing via protected template methods.
- *
- * @example Basic usage
- * ```typescript
- * const resolver = new oSearchResolver(nodeAddress);
- * router.addResolver(resolver);
- * ```
- *
- * @example Creating a custom search resolver
- * ```typescript
- * class CustomSearchResolver extends oSearchResolver {
- *   // Search a different registry
- *   protected getRegistryAddress(): oAddress {
- *     return new oAddress('o://my-custom-registry');
- *   }
- *
- *   // Use round-robin selection instead of first result
- *   private currentIndex = 0;
- *   protected selectResult(results: any[]): any | null {
- *     if (results.length === 0) return null;
- *     const result = results[this.currentIndex % results.length];
- *     this.currentIndex++;
- *     return result;
- *   }
- *
- *   // Add custom filtering logic
- *   protected filterSearchResults(results: any[], node: oCore): any[] {
- *     return super.filterSearchResults(results, node).filter(
- *       result => result.status === 'active'
- *     );
- *   }
- *
- *   // Implement custom routing logic with transport setup
- *   protected determineNextHop(
- *     node: oCore,
- *     resolvedTargetAddress: oAddress,
- *     searchResult: any
- *   ): oAddress {
- *     // Always route directly to target, bypassing hierarchy
- *     const targetTransports = this.mapTransports(searchResult);
- *     resolvedTargetAddress.setTransports(targetTransports);
- *     return resolvedTargetAddress;
- *   }
- * }
- * ```
- *
- * ## Extension Points
- *
- * The following protected methods can be overridden to customize behavior:
- *
- * - `getRegistryAddress()` - Change which registry to search
- * - `getSearchMethod()` - Change the registry method to call
- * - `buildSearchParams()` - Customize search parameters
- * - `filterSearchResults()` - Add custom filtering logic
- * - `selectResult()` - Implement custom result selection (e.g., load balancing)
- * - `mapTransports()` - Customize how transports are mapped from results
- * - `determineNextHop()` - Implement custom routing logic to determine the next hop address
- * - `resolveNextHopTransports()` - Customize transport resolution for the next hop
- */
-export class oSearchResolver extends oAddressResolver {
-    constructor(address) {
-        super(address);
-        this.address = address;
-    }
-    get customTransports() {
-        return [new oCustomTransport('/search')];
-    }
-    /**
-     * Returns the address of the registry to search.
-     * Override this method to search a different registry.
-     * @returns The registry address to query
-     */
-    getRegistryAddress() {
-        return new oAddress('o://leader/registry');
-    }
-    /**
-     * Returns the method name to call on the registry.
-     * Override this method to use a different search method.
-     * @returns The method name to call
-     */
-    getSearchMethod() {
-        return 'search';
-    }
-    /**
-     * Builds the search parameters for the registry query.
-     * Override this method to customize search parameters.
-     * @param address - The address being resolved
-     * @returns Parameters to pass to the registry search method
-     */
-    buildSearchParams(address) {
-        return {
-            staticAddress: address.toRootAddress().toString(),
-            address: address.toString(),
-        };
-    }
-    /**
-     * Filters the search results from the registry.
-     * Override this method to apply custom filtering logic.
-     * @param results - Raw results from the registry
-     * @param node - The current node context
-     * @returns Filtered array of results
-     */
-    filterSearchResults(results, node) {
-        return results.filter(
-        // filter out the items that may cause infinite looping
-        (result) => result.staticAddress !== RestrictedAddresses.REGISTRY &&
-            result.address !== node.address);
-    }
-    /**
-     * Selects which result to use from the filtered results.
-     * Override this method to implement custom selection logic (e.g., load balancing).
-     * @param results - Filtered search results
-     * @returns The selected result, or null if no suitable result
-     */
-    selectResult(results) {
-        return results.length > 0 ? results[0] : null;
-    }
-    /**
-     * Maps the transport data from the search result to oNodeTransport instances.
-     * Override this method to customize transport mapping.
-     * @param result - The selected search result
-     * @returns Array of oNodeTransport instances
-     */
-    mapTransports(result) {
-        return result.transports.map((t) => new oNodeTransport(t.value));
-    }
-    /**
-     * Resolves the transports for the next hop address.
-     * This handles the logic of determining which transports to use based on
-     * whether the next hop is the leader, a known child, or a new target.
-     *
-     * Override this method to customize transport resolution logic.
-     *
-     * @param nextHop - The next hop address
-     * @param targetTransports - The transports from the registry search result
-     * @param node - The current node context
-     * @returns Array of transports to use for the next hop
-     */
-    resolveNextHopTransports(nextHop, targetTransports, node) {
-        // If next hop is the leader, use leader transports
-        if (nextHop.value === RestrictedAddresses.LEADER) {
-            return (node.leader?.transports || []);
-        }
-        // Check if next hop is a known child in the hierarchy
-        const childAddress = node?.hierarchyManager.getChild(nextHop);
-        if (childAddress?.transports) {
-            return childAddress.transports;
-        }
-        // Fall back to target transports from registry
-        return targetTransports;
-    }
-    /**
-     * Determines the next hop address for routing to the target and sets up its transports.
-     *
-     * This method implements the complete routing logic including:
-     * 1. Determining the next address in the path (using `oAddress.next()`)
-     * 2. Mapping transports from the search result
-     * 3. Resolving and setting transports on the next hop address
-     * 4. Setting transports on the target address
-     *
-     * The default implementation:
-     * - Uses `oAddress.next()` for standard hierarchy-based routing
-     * - Maps transports from the registry search result
-     * - Resolves next hop transports based on leader/hierarchy
-     * - Configures both next hop and target with appropriate transports
-     *
-     * Override this method to implement custom routing logic, such as:
-     * - Direct peer-to-peer routing
-     * - Custom hierarchy traversal
-     * - Alternative transport selection strategies
-     * - Bypass leader for certain routes
-     *
-     * @param node - The current node context
-     * @param resolvedTargetAddress - The resolved target address to route to
-     * @param searchResult - The raw search result from the registry containing transport data
-     * @returns The next hop address with transports configured
-     *
-     * @example Custom direct routing
-     * ```typescript
-     * class DirectSearchResolver extends oSearchResolver {
-     *   protected determineNextHop(
-     *     node: oCore,
-     *     resolvedTargetAddress: oAddress,
-     *     searchResult: any
-     *   ): oAddress {
-     *     // Always route directly to the target, bypassing hierarchy
-     *     const targetTransports = this.mapTransports(searchResult);
-     *     resolvedTargetAddress.setTransports(targetTransports);
-     *     return resolvedTargetAddress;
-     *   }
-     * }
-     * ```
-     */
-    determineNextHop(node, resolvedTargetAddress, searchResult) {
-        // Determine next hop using standard hierarchy logic
-        const nextHopAddress = oAddress.next(node.address, resolvedTargetAddress);
-        // Map transports from search result
-        const targetTransports = this.mapTransports(searchResult);
-        // Set transports on the next hop based on routing logic
-        nextHopAddress.setTransports(this.resolveNextHopTransports(nextHopAddress, targetTransports, node));
-        return nextHopAddress;
-    }
-    async resolve(request) {
-        const { address, node, request: resolveRequest, targetAddress } = request;
-        // Early return: if address already has transports, no search needed
-        if (address.transports.length > 0) {
-            return {
-                nextHopAddress: address,
-                targetAddress: targetAddress,
-                requestOverride: resolveRequest,
-            };
-        }
-        if (node.state !== NodeState.RUNNING) {
-            return {
-                nextHopAddress: address,
-                targetAddress: targetAddress,
-                requestOverride: resolveRequest,
-            };
-        }
-        // Perform registry search with error handling
-        const searchParams = this.buildSearchParams(address);
-        const registryAddress = this.getRegistryAddress();
-        let searchResponse;
-        try {
-            searchResponse = await node.use(registryAddress, {
-                method: this.getSearchMethod(),
-                params: searchParams,
-            });
-        }
-        catch (error) {
-            // Log the error but don't throw - allow fallback resolvers to handle it
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Check if this is a circuit breaker error (fast-fail scenario)
-            if (errorMessage.includes('Circuit breaker is OPEN')) {
-                this.logger.warn(`Registry search blocked by circuit breaker for ${address.toString()}: ${errorMessage}`);
-            }
-            else {
-                this.logger.error(`Registry search failed for ${address.toString()}: ${errorMessage}`);
-            }
-            // Return original address without transports, letting next resolver in chain handle it
-            return {
-                nextHopAddress: address,
-                targetAddress: targetAddress,
-                requestOverride: resolveRequest,
-            };
-        }
-        // Filter and select result
-        const filteredResults = this.filterSearchResults(searchResponse.result.data, node);
-        const selectedResult = this.selectResult(filteredResults);
-        // Early return: if no result found, return original address
-        if (!selectedResult) {
-            return {
-                nextHopAddress: address,
-                targetAddress: targetAddress,
-                requestOverride: resolveRequest,
-            };
-        }
-        // Build route from search result
-        const extraParams = address
-            .toString() // o://embeddings-text replace o://embeddings-text = ''
-            .replace(address.toRootAddress().toString(), '');
-        // Check if selectedResult.address already contains the complete path
-        // This happens when registry finds via staticAddress - the returned address
-        // is the canonical hierarchical location, so we shouldn't append extraParams
-        const resultAddress = selectedResult.address;
-        const shouldAppendParams = extraParams && !resultAddress.endsWith(extraParams);
-        const resolvedTargetAddress = new oAddress(shouldAppendParams ? resultAddress + extraParams : resultAddress);
-        // Set transports on the target address
-        resolvedTargetAddress.setTransports(this.mapTransports(selectedResult));
-        // Determine next hop and configure transports
-        const nextHopAddress = this.determineNextHop(node, resolvedTargetAddress, selectedResult);
-        return {
-            nextHopAddress: nextHopAddress,
-            targetAddress: resolvedTargetAddress,
-            requestOverride: resolveRequest,
-        };
-    }
-}

package/dist/o-node/src/router/route.request.d.ts

@@ -1,14 +0,0 @@
-import { RequestParams } from '@olane/o-protocol';
-import { oRequest } from '@olane/o-core';
-import { Stream } from '@olane/o-config';
-export interface RouteRequest extends oRequest {
-    stream: Stream;
-    params: RequestParams & {
-        address: string;
-        payload: {
-            method: string;
-            params: RequestParams;
-        };
-    };
-}
-//# sourceMappingURL=route.request.d.ts.map

package/dist/o-node/src/router/route.request.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"route.request.d.ts","sourceRoot":"","sources":["../../../../src/router/route.request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,MAAM,WAAW,YAAa,SAAQ,QAAQ;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,aAAa,GAAG;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE;YACP,MAAM,EAAE,MAAM,CAAC;YACf,MAAM,EAAE,aAAa,CAAC;SACvB,CAAC;KACH,CAAC;CACH"}

package/dist/o-node/src/router/route.request.js

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

package/dist/o-node/src/streaming/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Streaming functionality for o-node
- *
- * This module provides libp2p-specific implementations of the streaming
- * abstractions defined in o-core.
- */
-export * from '../../../o-core/src/streaming/index.js';
-export { Libp2pStreamTransport } from './libp2p-stream-transport.js';
-export { NodeStreamHandler, NodeStreamHandlerOptions, } from './node-stream-handler.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/o-node/src/streaming/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/streaming/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,wCAAwC,CAAC;AAGvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAGrE,OAAO,EACL,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,0BAA0B,CAAC"}

package/dist/o-node/src/streaming/index.js

@@ -1,12 +0,0 @@
-/**
- * Streaming functionality for o-node
- *
- * This module provides libp2p-specific implementations of the streaming
- * abstractions defined in o-core.
- */
-// Re-export o-core streaming abstractions for convenience
-export * from '../../../o-core/src/streaming/index.js';
-// libp2p-specific stream transport
-export { Libp2pStreamTransport } from './libp2p-stream-transport.js';
-// o-node stream handler with metrics
-export { NodeStreamHandler, } from './node-stream-handler.js';

package/dist/o-node/src/streaming/libp2p-stream-transport.d.ts

@@ -1,50 +0,0 @@
-import { Stream } from '@olane/o-config';
-import { IStreamTransport, StreamStatus, StreamTransportConfig } from '../../../o-core/src/streaming/index.js';
-/**
- * libp2p-specific implementation of IStreamTransport.
- * Wraps a libp2p Stream and handles backpressure, message listening,
- * and stream lifecycle management.
- */
-export declare class Libp2pStreamTransport implements IStreamTransport {
-    private readonly stream;
-    private messageHandler?;
-    private config;
-    constructor(stream: Stream, config?: StreamTransportConfig);
-    /**
-     * Get the underlying libp2p Stream (useful for advanced use cases)
-     */
-    getStream(): Stream;
-    /**
-     * Send data through the stream with backpressure handling
-     */
-    send(data: Uint8Array): Promise<void>;
-    /**
-     * Set up a message handler for incoming data.
-     * IMPORTANT: For libp2p v3, this must be called synchronously after
-     * receiving the stream to prevent buffer overflow.
-     */
-    onMessage(handler: (data: Uint8Array) => void): void;
-    /**
-     * Remove the message handler
-     */
-    removeMessageHandler(): void;
-    /**
-     * Close the stream and clean up resources
-     */
-    close(): Promise<void>;
-    /**
-     * Get the current status of the stream
-     */
-    getStatus(): StreamStatus;
-    /**
-     * Check if the stream is in a usable state
-     */
-    isOpen(): boolean;
-    /**
-     * Wait for the first message with timeout
-     * @param timeoutMs - Optional timeout in milliseconds (defaults to config.readTimeoutMs)
-     * @returns Promise that resolves with the first message
-     */
-    waitForMessage(timeoutMs?: number): Promise<Uint8Array>;
-}
-//# sourceMappingURL=libp2p-stream-transport.d.ts.map

package/dist/o-node/src/streaming/libp2p-stream-transport.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"libp2p-stream-transport.d.ts","sourceRoot":"","sources":["../../../../src/streaming/libp2p-stream-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,qBAAqB,EACtB,MAAM,wCAAwC,CAAC;AAUhD;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,gBAAgB;IAK1D,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJzB,OAAO,CAAC,cAAc,CAAC,CAA6B;IACpD,OAAO,CAAC,MAAM,CAAkC;gBAG7B,MAAM,EAAE,MAAM,EAC/B,MAAM,CAAC,EAAE,qBAAqB;IAQhC;;OAEG;IACI,SAAS,IAAI,MAAM;IAI1B;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAwB3C;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI;IAcpD;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAO5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;OAEG;IACH,SAAS,IAAI,YAAY;IAkBzB;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;;;OAIG;IACG,cAAc,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAe9D"}

package/dist/o-node/src/streaming/libp2p-stream-transport.js

@@ -1,137 +0,0 @@
-import { StreamStatus, } from '../../../o-core/src/streaming/index.js';
-/**
- * Default configuration for libp2p stream transport
- */
-const DEFAULT_CONFIG = {
-    drainTimeoutMs: 30000, // 30 seconds
-    readTimeoutMs: 120000, // 2 minutes
-};
-/**
- * libp2p-specific implementation of IStreamTransport.
- * Wraps a libp2p Stream and handles backpressure, message listening,
- * and stream lifecycle management.
- */
-export class Libp2pStreamTransport {
-    constructor(stream, config) {
-        this.stream = stream;
-        this.config = {
-            ...DEFAULT_CONFIG,
-            ...config,
-        };
-    }
-    /**
-     * Get the underlying libp2p Stream (useful for advanced use cases)
-     */
-    getStream() {
-        return this.stream;
-    }
-    /**
-     * Send data through the stream with backpressure handling
-     */
-    async send(data) {
-        // Check stream status before sending
-        if (this.stream.status !== 'open') {
-            throw new Error(`Cannot send on stream with status: ${this.stream.status}`);
-        }
-        try {
-            // Attempt to send the data
-            const sent = this.stream.send(data);
-            // Handle backpressure if the buffer is full
-            if (!sent) {
-                // Wait for the stream to drain with timeout
-                await this.stream.onDrain({
-                    signal: AbortSignal.timeout(this.config.drainTimeoutMs),
-                });
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to send data: ${error}`);
-        }
-    }
-    /**
-     * Set up a message handler for incoming data.
-     * IMPORTANT: For libp2p v3, this must be called synchronously after
-     * receiving the stream to prevent buffer overflow.
-     */
-    onMessage(handler) {
-        this.messageHandler = handler;
-        // Attach the message listener to the stream
-        // This is synchronous and must be done immediately for libp2p v3
-        this.stream.addEventListener('message', (event) => {
-            if (this.messageHandler) {
-                // Extract the data from the event
-                const data = event.detail;
-                this.messageHandler(data);
-            }
-        });
-    }
-    /**
-     * Remove the message handler
-     */
-    removeMessageHandler() {
-        this.messageHandler = undefined;
-        // Note: We don't remove the event listener because libp2p doesn't
-        // provide a clean way to do this. The handler being undefined
-        // effectively disables it.
-    }
-    /**
-     * Close the stream and clean up resources
-     */
-    async close() {
-        try {
-            if (this.stream.status === 'open' || this.stream.status === 'closing') {
-                await this.stream.close();
-            }
-        }
-        catch (error) {
-            console.error('Error closing stream:', error);
-            // Don't throw - closing errors are not critical
-        }
-        finally {
-            this.removeMessageHandler();
-        }
-    }
-    /**
-     * Get the current status of the stream
-     */
-    getStatus() {
-        // Map libp2p status to our StreamStatus enum
-        const status = this.stream.status;
-        switch (status) {
-            case 'open':
-                return StreamStatus.OPEN;
-            case 'closing':
-                return StreamStatus.CLOSING;
-            case 'closed':
-                return StreamStatus.CLOSED;
-            case 'reset':
-                return StreamStatus.RESET;
-            default:
-                return StreamStatus.CLOSED;
-        }
-    }
-    /**
-     * Check if the stream is in a usable state
-     */
-    isOpen() {
-        return this.stream.status === 'open';
-    }
-    /**
-     * Wait for the first message with timeout
-     * @param timeoutMs - Optional timeout in milliseconds (defaults to config.readTimeoutMs)
-     * @returns Promise that resolves with the first message
-     */
-    async waitForMessage(timeoutMs) {
-        const timeout = timeoutMs ?? this.config.readTimeoutMs;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.removeMessageHandler();
-                reject(new Error(`Timeout waiting for message after ${timeout}ms`));
-            }, timeout);
-            this.onMessage((data) => {
-                clearTimeout(timer);
-                resolve(data);
-            });
-        });
-    }
-}

package/dist/o-node/src/streaming/node-stream-handler.d.ts

@@ -1,65 +0,0 @@
-import { StreamHandlerBase, StreamHandlerOptions } from '../../../o-core/src/streaming/index.js';
-import { oRequest } from '@olane/o-protocol';
-import { Libp2pStreamTransport } from './libp2p-stream-transport.js';
-/**
- * Options for NodeStreamHandler
- */
-export interface NodeStreamHandlerOptions extends StreamHandlerOptions {
-    /**
-     * Enable success count tracking
-     */
-    trackSuccessCount?: boolean;
-    /**
-     * Enable error count tracking
-     */
-    trackErrorCount?: boolean;
-}
-/**
- * o-node specific implementation of StreamHandlerBase.
- * Integrates with libp2p streams and tracks metrics for o-node tools.
- */
-export declare class NodeStreamHandler extends StreamHandlerBase {
-    private successCount;
-    private errorCount;
-    private transport;
-    private nodeOptions;
-    constructor(transport: Libp2pStreamTransport, options?: NodeStreamHandlerOptions);
-    /**
-     * Get the success count (number of chunks successfully sent)
-     */
-    getSuccessCount(): number;
-    /**
-     * Get the error count
-     */
-    getErrorCount(): number;
-    /**
-     * Reset metrics
-     */
-    resetMetrics(): void;
-    /**
-     * Implementation of sendChunk using libp2p transport and protocol builder
-     */
-    protected sendChunk(chunk: unknown, sequence: number, isLast: boolean, request: oRequest): Promise<void>;
-    /**
-     * Hook: Called when streaming starts
-     */
-    protected onStreamStart(request: oRequest): void;
-    /**
-     * Hook: Called when streaming completes successfully
-     */
-    protected onStreamComplete(request: oRequest, totalChunks: number): void;
-    /**
-     * Hook: Called when streaming encounters an error
-     */
-    protected onStreamError(request: oRequest, error: any): void;
-    /**
-     * Reset the handler for reuse with a new transport
-     */
-    reset(): void;
-    /**
-     * Create a new NodeStreamHandler with a different transport
-     * (useful for handling multiple streams)
-     */
-    static create(transport: Libp2pStreamTransport, options?: NodeStreamHandlerOptions): NodeStreamHandler;
-}
-//# sourceMappingURL=node-stream-handler.d.ts.map

package/dist/o-node/src/streaming/node-stream-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-stream-handler.d.ts","sourceRoot":"","sources":["../../../../src/streaming/node-stream-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EAErB,MAAM,wCAAwC,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,oBAAoB;IACpE;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAE5B;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB;IACtD,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,SAAS,CAAwB;IACzC,OAAO,CAAC,WAAW,CAA2B;gBAG5C,SAAS,EAAE,qBAAqB,EAChC,OAAO,GAAE,wBAA6B;IAWxC;;OAEG;IACI,eAAe,IAAI,MAAM;IAIhC;;OAEG;IACI,aAAa,IAAI,MAAM;IAI9B;;OAEG;IACI,YAAY,IAAI,IAAI;IAK3B;;OAEG;cACa,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,IAAI,CAAC;IA0BhB;;OAEG;cACgB,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAOzD;;OAEG;cACgB,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IASjF;;OAEG;cACgB,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAUrE;;OAEG;IACI,KAAK,IAAI,IAAI;IAOpB;;;OAGG;WACW,MAAM,CAClB,SAAS,EAAE,qBAAqB,EAChC,OAAO,CAAC,EAAE,wBAAwB,GACjC,iBAAiB;CAGrB"}