@olane/o-core 0.6.13 → 0.7.2

package/dist/src/node/lib/network-activity.lib.js

@@ -1,29 +0,0 @@
-export const NETWORK_ACTIVITY_EVENTS = [
-    'peer:connect',
-    'peer:disconnect',
-    'peer:update',
-    'peer:discovery',
-    'peer:reconnect-failure',
-    'peer:identify',
-    'transport:listening',
-    'transport:close',
-    'connection:prune',
-    'connection:open',
-    'connection:close',
-    'certificate:provision',
-    'certificate:renew',
-];
-export class NetworkActivity {
-    constructor(logger, p2pNode) {
-        this.logger = logger;
-        this.p2pNode = p2pNode;
-        this.setup();
-    }
-    setup() {
-        for (const event of NETWORK_ACTIVITY_EVENTS) {
-            this.p2pNode.addEventListener(event, (evt) => {
-                this.logger.debug('Network activity: ', event, evt.detail);
-            });
-        }
-    }
-}

package/dist/src/node/node.d.ts

@@ -1,45 +0,0 @@
-import { Libp2pConfig } from '@olane/o-config';
-import { oAddress, oCoreNode, oRequest, oResponse } from '../core/index.js';
-import { NetworkActivity } from './lib/network-activity.lib.js';
-import { CID } from 'multiformats';
-import { oHandshakeResult } from '../plan/interfaces/handshake.result.js';
-import { RouteRequest } from './interfaces/route.request.js';
-export declare abstract class oNode extends oCoreNode {
-    networkActivity: NetworkActivity;
-    childNodes: oNode[];
-    childAddresses: oAddress[];
-    validate(): void;
-    _tool_handshake(handshake: oRequest): Promise<oHandshakeResult>;
-    abstract configureTransports(): any[];
-    myTools(obj?: any): string[];
-    applyBridgeTransports(address: oAddress, request: oRequest): Promise<oResponse>;
-    matchAgainstMethods(address: oAddress): Promise<boolean>;
-    extractMethod(address: oAddress): string;
-    _tool_route(request: RouteRequest): Promise<any>;
-    /**
-     * Where all intents go to be resolved.
-     * @param request
-     * @returns
-     */
-    _tool_intent(request: oRequest): Promise<any>;
-    _tool_child_register(request: oRequest): Promise<any>;
-    start(): Promise<void>;
-    startChildren(): Promise<void>;
-    validateJoinRequest(request: oRequest): Promise<any>;
-    _tool_add_child(request: oRequest): Promise<any>;
-    addChildNode(node: oNode): void;
-    removeChildNode(node: oNode): void;
-    /**
-     * Configure the libp2p node
-     * @returns The libp2p config
-     */
-    configure(): Promise<Libp2pConfig>;
-    initialize(): Promise<void>;
-    dhtProvide(value: CID): Promise<void>;
-    advertiseValueToNetwork(value: CID): Promise<void>;
-    get isServer(): boolean;
-    advertiseToNetwork(): Promise<void>;
-    listenForNetworkEvents(): void;
-    teardown(): Promise<void>;
-}
-//# sourceMappingURL=node.d.ts.map

package/dist/src/node/node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/node/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,YAAY,EAMb,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAIL,QAAQ,EAER,SAAS,EACT,QAAQ,EACR,SAAS,EACV,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAMhE,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AACnC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAC1E,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAK7D,8BAAsB,KAAM,SAAQ,SAAS;IACpC,eAAe,EAAG,eAAe,CAAC;IAClC,UAAU,EAAE,KAAK,EAAE,CAAM;IACzB,cAAc,EAAE,QAAQ,EAAE,CAAM;IAEvC,QAAQ,IAAI,IAAI;IASV,eAAe,CAAC,SAAS,EAAE,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAkBrE,QAAQ,CAAC,mBAAmB,IAAI,GAAG,EAAE;IAErC,OAAO,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE;IAOtB,qBAAqB,CACzB,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,SAAS,CAAC;IAOf,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC;IAS9D,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM;IAIlC,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC;IA8EtD;;;;OAIG;IACG,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAiC7C,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IASrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IA2C9B,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAIpD,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAYtD,YAAY,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI;IAK/B,eAAe,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI;IAIlC;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;IAqFlC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB3B,UAAU,CAAC,KAAK,EAAE,GAAG;IAiBrB,uBAAuB,CAAC,KAAK,EAAE,GAAG;IAiBxC,IAAI,QAAQ,IAAI,OAAO,CAItB;IAEK,kBAAkB;IA6BxB,sBAAsB;IAIhB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAOhC"}

package/dist/src/node/node.js

@@ -1,359 +0,0 @@
-import { bootstrap, createNode, defaultLibp2pConfig, multiaddr, pipe, pushable, } from '@olane/o-config';
-import { CoreUtils, NodeState, NodeType, oAddress, oConnectionManager, oCoreNode, oRequest, } from '../core/index.js';
-import { NextHopResolver } from '../core/lib/resolvers/next-hop.resolver.js';
-import { NetworkActivity } from './lib/network-activity.lib.js';
-import { oToolError } from '../error/tool.error.js';
-import { oToolErrorCodes } from '../error/enums/codes.error.js';
-import { oAgentPlan } from '../plan/agent.plan.js';
-import { oPlanContext } from '../plan/plan.context.js';
-import { v4 as uuidv4 } from 'uuid';
-// Enable default Node.js metrics
-// collectDefaultMetrics({ register: sharedRegistry });
-export class oNode extends oCoreNode {
-    constructor() {
-        super(...arguments);
-        this.childNodes = [];
-        this.childAddresses = [];
-    }
-    validate() {
-        if (this.p2pNode && this.state !== NodeState.STOPPED) {
-            throw new Error('Node is not in a valid state to be initialized');
-        }
-        if (!this.address.validate()) {
-            throw new Error('Invalid address');
-        }
-    }
-    async _tool_handshake(handshake) {
-        this.logger.debug('Performing handshake with intent: ', handshake.params.intent);
-        const mytools = await this.myTools();
-        return {
-            tools: mytools.filter((t) => t !== 'handshake' && t !== 'intent'),
-            methods: this.methods,
-            successes: [],
-            failures: [],
-            task: undefined,
-            type: 'handshake',
-        };
-    }
-    myTools(obj) {
-        return Object.getOwnPropertyNames(obj || this.constructor.prototype)
-            .filter((key) => key.startsWith('_tool_'))
-            .filter((key) => !!key)
-            .map((key) => key.replace('_tool_', ''));
-    }
-    async applyBridgeTransports(address, request) {
-        throw new oToolError(oToolErrorCodes.TOOL_TRANSPORT_NOT_SUPPORTED, 'Bridge transports not implemented');
-    }
-    async matchAgainstMethods(address) {
-        const methods = await this.myTools();
-        this.logger.debug('Matching against methods: ', methods);
-        const method = address
-            .toString()
-            .replace(this.address.toString() + '/', '');
-        return methods.includes(method || '');
-    }
-    extractMethod(address) {
-        return address.protocol.split('/').pop() || '';
-    }
-    async _tool_route(request) {
-        const { payload } = request.params;
-        const { address } = request.params;
-        this.logger.debug('Routing request to: ', address);
-        const destinationAddress = new oAddress(address);
-        // determine the next hop address from the encapsulated address
-        const nextHopAddress = await this.addressResolution.resolve(destinationAddress);
-        this.logger.debug('Next hop address: ', nextHopAddress.toString(), nextHopAddress.transports);
-        // prepare the request for the destination receiver
-        let forwardRequest = new oRequest({
-            params: payload.params,
-            id: request.id,
-            method: payload.method,
-        });
-        // if the next hop is not a libp2p address, we need to communicate to it another way
-        if (this.addressResolution.supportsTransport(nextHopAddress)) {
-            this.logger.debug('Bridge transports supported, applying custom transports...');
-            this.logger.debug('Next hop address: BRENDON!');
-            // attempt to resolve with bridge transports
-            return this.applyBridgeTransports(nextHopAddress, forwardRequest);
-        }
-        // assume the next hop is a libp2p address, so we need to set the transports and dial it
-        nextHopAddress.setTransports(this.getTransports(nextHopAddress));
-        const isAtDestination = nextHopAddress.value === destinationAddress.value;
-        // if we are at the destination, let's look for the closest tool that can service the request
-        const transports = nextHopAddress.transports.filter((t) => typeof t !== 'string');
-        const isMethodMatch = await this.matchAgainstMethods(destinationAddress);
-        // handle address -> method resolution
-        if (isMethodMatch) {
-            this.logger.debug('Method match found, forwarding to self...');
-            const extractedMethod = this.extractMethod(destinationAddress);
-            try {
-                const response = await this.use(this.address, {
-                    method: payload.method || extractedMethod,
-                    params: payload.params,
-                });
-                return response.result.data;
-            }
-            catch (error) {
-                return error;
-            }
-        }
-        const targetStream = await this.p2pNode.dialProtocol(transports, nextHopAddress.protocol);
-        // if not at destination, we need to forward the request to the target
-        if (!isAtDestination) {
-            forwardRequest = new oRequest(request);
-        }
-        else {
-            this.logger.debug('At destination!');
-        }
-        const pushableStream = pushable();
-        pushableStream.push(new TextEncoder().encode(forwardRequest.toString()));
-        pushableStream.end();
-        await targetStream.sink(pushableStream);
-        await pipe(targetStream.source, request.stream.sink);
-    }
-    /**
-     * Where all intents go to be resolved.
-     * @param request
-     * @returns
-     */
-    async _tool_intent(request) {
-        this.logger.debug('Intent resolution called: ', request.params);
-        const { intent, context, streamTo } = request.params;
-        const pc = new oAgentPlan({
-            intent: intent,
-            currentNode: this,
-            caller: this.address,
-            streamTo: new oAddress(streamTo),
-            context: context
-                ? new oPlanContext([
-                    `[Chat History Context Begin]\n${context}\n[Chat History Context End]`,
-                ])
-                : undefined,
-            shouldContinue: () => {
-                return !!this.requests[request.id];
-            },
-        });
-        const response = await pc.execute();
-        return {
-            ...response,
-            cycles: pc.sequence.length,
-            sequence: pc.sequence.map((s) => {
-                return {
-                    reasoning: s.result?.reasoning,
-                    result: s.result?.result,
-                    error: s.result?.error,
-                    type: s.result?.type,
-                };
-            }),
-        };
-    }
-    async _tool_child_register(request) {
-        const { address } = request.params;
-        const childAddress = new oAddress(address);
-        this.childAddresses.push(childAddress);
-        return {
-            message: 'Child node registered with parent!',
-        };
-    }
-    async start() {
-        await super.start();
-        await this.startChildren();
-        await this.advertiseToNetwork();
-    }
-    // deprecated virtual node startup
-    async startChildren() {
-        this.logger.debug('Initializing contained children nodes...', this.childNodes.length);
-        await Promise.all(this.childNodes.map(async (node) => {
-            try {
-                if (node.state !== NodeState.STOPPED) {
-                    return;
-                }
-                node.config.parent = this.address;
-                // forward the network leader address to the child node
-                if (this.type === NodeType.LEADER) {
-                    node.config.leader = this.address;
-                }
-                else {
-                    node.config.leader = this.config.leader;
-                }
-                node.config.parent = this.address;
-                // node.address = CoreUtils.childAddress(this.address, node.address);
-                this.logger.debug('Starting virtual node: ' +
-                    node.address.toString() +
-                    ' with parent transports: ' +
-                    node.parentTransports.join(', '));
-                await node.start();
-                this.logger.debug('Child node started: ', node.address.toString());
-                // test the connection to the child node to add it to the p2p network peer store
-                await this.connect(node.address, node.address);
-            }
-            catch (error) {
-                this.logger.error('Failed to start virtual node: ' + node.address.toString(), error);
-            }
-        }));
-        // await new Promise((resolve) => setTimeout(resolve, 1_000));
-    }
-    async validateJoinRequest(request) {
-        return true;
-    }
-    async _tool_add_child(request) {
-        const { address, transports } = request.params;
-        const childAddress = new oAddress(address, transports.map((t) => multiaddr(t)));
-        this.childAddresses.push(childAddress);
-        return {
-            message: 'Child node registered with parent!',
-        };
-    }
-    addChildNode(node) {
-        this.logger.debug('Adding virtual node: ' + node.address.toString());
-        this.childNodes.push(node);
-    }
-    removeChildNode(node) {
-        this.childNodes = this.childNodes.filter((n) => n !== node);
-    }
-    /**
-     * Configure the libp2p node
-     * @returns The libp2p config
-     */
-    async configure() {
-        const params = {
-            ...this.networkConfig,
-            transports: this.configureTransports(),
-            connectionManager: {
-                ...(this.networkConfig.connectionManager || {
-                    minConnections: 10, // Keep at least 10 connections
-                    maxConnections: 100, // Allow up to 100 connections
-                    pollInterval: 2000, // Check connections every 2 seconds
-                    autoDialInterval: 10000, // Auto-dial new peers every 10 seconds
-                    dialTimeout: 30000, // 30 second dial timeout
-                }),
-            },
-            listeners: (this.config.network?.listeners ||
-                defaultLibp2pConfig.listeners ||
-                []).concat(`/memory/${uuidv4()}`), // ensure we allow for local in-memory communication
-        };
-        // if the seed is provided, use it to generate the private key
-        if (this.config.seed) {
-            this.logger.debug('Seed provided, generating private key...');
-            const privateKey = await CoreUtils.generatePrivateKey(this.config.seed);
-            params.privateKey = privateKey;
-        }
-        else {
-            this.logger.debug('No seed provided, generating private key...');
-            this.logger.debug('Without providing a seed, this node peer id will be destroyed after the node shuts down.');
-            // TODO: add a link to documentation about how to setup a seed
-        }
-        // if config.bootstrapTransports is provided, use it to bootstrap the node
-        const leaderTransports = this.config.leader?.transports;
-        if (leaderTransports && leaderTransports.length > 0) {
-            this.leaders = leaderTransports;
-        }
-        // this is a child node of the network, so communication is heavily restricted
-        if (this.parentTransports.length > 0) {
-            // peer discovery is only allowed through the parent transports
-            params.peerDiscovery = [
-                bootstrap({
-                    list: [...this.parentTransports.map((t) => t.toString())],
-                }),
-                ...(defaultLibp2pConfig.peerDiscovery || []),
-            ];
-            //   // let's make sure we only allow communication through the parent transports
-            params.connectionGater = {
-                // who can call us?
-                denyInboundEncryptedConnection: (peerId, maConn) => {
-                    // deny all inbound connections unless they are from a parent transport
-                    if (this.parentPeerId === peerId.toString()) {
-                        return false;
-                    }
-                    // allow leader inbounds
-                    if (this.config.type === NodeType.LEADER) {
-                        return false;
-                    }
-                    // deny everything else
-                    return true;
-                },
-                // allow the user to override the default connection gater
-                ...(this.config.network?.connectionGater || {}),
-            };
-        }
-        // handle the address encapsulation
-        if (this.config.leader &&
-            !this.address.protocol.includes(this.config.leader.protocol)) {
-            const parentAddress = this.config.parent || this.config.leader;
-            this.logger.debug('Encapsulating address: ' + this.address.toString(), parentAddress.toString());
-            this.address = CoreUtils.childAddress(parentAddress, this.address);
-        }
-        return params;
-    }
-    async initialize() {
-        this.logger.debug('Initializing node...');
-        this.validate();
-        const params = await this.configure();
-        this.p2pNode = await createNode(params);
-        this.logger.debug('Node initialized!', this.transports);
-        this.address.setTransports(this.transports.map((t) => multiaddr(t)));
-        this.peerId = this.p2pNode.peerId;
-        // initialize connection manager
-        this.connectionManager = new oConnectionManager({
-            logger: this.logger,
-            p2pNode: this.p2pNode,
-        });
-        // initialize address resolution
-        this.addressResolution.addResolver(new NextHopResolver(this.address, this.p2pNode));
-        // listen for network events
-        // this.listenForNetworkEvents();
-    }
-    async dhtProvide(value) {
-        if (!this.config.parent && !this.config.leader) {
-            return;
-        }
-        for await (const event of this.p2pNode.services.dht.provide(value)) {
-            if (event.name === 'PATH_ENDED' ||
-                event.name === 'QUERY_ERROR' ||
-                event.name === 'PEER_RESPONSE') {
-                break;
-            }
-        }
-    }
-    async advertiseValueToNetwork(value) {
-        if (!this.isServer) {
-            return;
-        }
-        this.logger.debug('Advertising value to network: ', value.toString());
-        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Advertise Content routing provide timeout')), 5000));
-        await Promise.race([this.dhtProvide(value), timeoutPromise]);
-        this.logger.debug('Advertise complete!');
-    }
-    // if the node has any transports that are not memory, it is a server
-    get isServer() {
-        return (this.transports.filter((t) => t.includes('memory') === false).length > 0);
-    }
-    async advertiseToNetwork() {
-        if (!this.isServer) {
-            return;
-        }
-        this.logger.debug('Advertising to network our static and absolute addresses...');
-        // advertise the absolute address to the network with timeout
-        const absoluteAddressCid = await this.address.toCID();
-        // Add timeout to prevent hanging
-        this.advertiseValueToNetwork(absoluteAddressCid).catch((error) => {
-            this.logger.warn('Failed to advertise absolute address (this is normal for isolated nodes):', error.message);
-        });
-        // advertise the static address to the network with timeout
-        const staticAddressCid = await this.staticAddress.toCID();
-        // Add timeout to prevent hanging
-        this.advertiseValueToNetwork(staticAddressCid).catch((error) => {
-            this.logger.warn('Failed to advertise absolute address (this is normal for isolated nodes):', error.message);
-        });
-    }
-    listenForNetworkEvents() {
-        this.networkActivity = new NetworkActivity(this.logger, this.p2pNode);
-    }
-    async teardown() {
-        for (const node of this.childNodes) {
-            await node.stop();
-        }
-        this.childNodes = [];
-        return super.teardown();
-    }
-}

package/dist/src/node-virtual/index.d.ts

@@ -1,2 +0,0 @@
-export * from './virtual.node.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/node-virtual/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/node-virtual/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/src/node-virtual/index.js

@@ -1 +0,0 @@
-export * from './virtual.node.js';

package/dist/src/node-virtual/virtual.node.d.ts

@@ -1,10 +0,0 @@
-import { oNode } from '../node/node.js';
-export declare class oVirtualNode extends oNode {
-    /**
-     * Virtual nodes are only used for local communication, so we need to configure
-     * the transports to be in-memory.
-     * @returns The transports for the virtual node
-     */
-    configureTransports(): any[];
-}
-//# sourceMappingURL=virtual.node.d.ts.map

package/dist/src/node-virtual/virtual.node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"virtual.node.d.ts","sourceRoot":"","sources":["../../../src/node-virtual/virtual.node.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAExC,qBAAa,YAAa,SAAQ,KAAK;IACrC;;;;OAIG;IACH,mBAAmB,IAAI,GAAG,EAAE;CAG7B"}

package/dist/src/node-virtual/virtual.node.js

@@ -1,12 +0,0 @@
-import { defaultLibp2pConfig } from '@olane/o-config';
-import { oNode } from '../node/node.js';
-export class oVirtualNode extends oNode {
-    /**
-     * Virtual nodes are only used for local communication, so we need to configure
-     * the transports to be in-memory.
-     * @returns The transports for the virtual node
-     */
-    configureTransports() {
-        return [...(defaultLibp2pConfig.transports || [])];
-    }
-}

package/dist/src/plan/agent.plan.d.ts

@@ -1,28 +0,0 @@
-import { oPlanResult } from './interfaces/plan.result.js';
-import { oPlanConfig } from './interfaces/plan-config.interface.js';
-import { oPlan } from './o-plan.js';
-import { oQueryConfig } from './interfaces/query.config.js';
-import { oTaskConfig } from './interfaces/task.config.js';
-/**
- * oAgentPlan is responsible for managing the execution of plans.
- * General execution flow:
- * 1. Analyze intent
- * 2. Search for context
- * 3. Use network tools + context to solve intent
- * 4. Back to step 1
- */
-export declare class oAgentPlan extends oPlan {
-    private MAX_ITERATIONS;
-    private contextIdHash;
-    constructor(config: oPlanConfig);
-    doTask(task: oTaskConfig, config: oPlanConfig): Promise<oPlanResult>;
-    handleTasks(results: oPlanResult, config: oPlanConfig): Promise<oPlanResult[]>;
-    handleSearch(queries: oQueryConfig[], config: oPlanConfig): Promise<any[]>;
-    /**
-     * The analysis of the intent results in a list of steps and queries to complete the intent.
-     */
-    handleMultipleStep(output: oPlanResult): Promise<oPlanResult>;
-    loop(): Promise<oPlanResult>;
-    run(): Promise<oPlanResult>;
-}
-//# sourceMappingURL=agent.plan.d.ts.map

package/dist/src/plan/agent.plan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent.plan.d.ts","sourceRoot":"","sources":["../../../src/plan/agent.plan.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACpE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAGpC,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAE1D;;;;;;;GAOG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,OAAO,CAAC,cAAc,CAAM;IAC5B,OAAO,CAAC,aAAa,CAAkC;gBAE3C,MAAM,EAAE,WAAW;IAIzB,MAAM,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAuBpE,WAAW,CACf,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,WAAW,EAAE,CAAC;IAmBnB,YAAY,CAChB,OAAO,EAAE,YAAY,EAAE,EACvB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,GAAG,EAAE,CAAC;IAmCjB;;OAEG;IACG,kBAAkB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAmB7D,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC;IAiG5B,GAAG,IAAI,OAAO,CAAC,WAAW,CAAC;CAGlC"}