@replit/river 0.6.4 → 0.7.1

package/dist/transport/transport.js

@@ -0,0 +1,241 @@
+import { Value } from '@sinclair/typebox/value';
+import { OpaqueTransportMessageSchema, TransportAckSchema, isAck, reply, } from './message';
+import { log } from '../logging';
+/**
+ * Abstract base for a connection between two nodes in a River network.
+ * A connection is responsible for sending and receiving messages on a 1:1
+ * basis between nodes.
+ * Connections can be reused across different transports.
+ * @abstract
+ */
+export class Connection {
+    connectedTo;
+    transport;
+    constructor(transport, connectedTo) {
+        this.connectedTo = connectedTo;
+        this.transport = transport;
+    }
+    onMessage(msg) {
+        return this.transport.onMessage(msg);
+    }
+}
+/**
+ * Abstract base for a transport layer for communication between nodes in a River network.
+ * A transport is responsible for handling the 1:n connection logic between nodes and
+ * delegating sending/receiving to connections.
+ * Any River transport methods need to implement this interface.
+ * @abstract
+ */
+export class Transport {
+    /**
+     * A flag indicating whether the transport has been destroyed.
+     * A destroyed transport will not attempt to reconnect and cannot be used again.
+     */
+    state;
+    /**
+     * The {@link Codec} used to encode and decode messages.
+     */
+    codec;
+    /**
+     * The client ID of this transport.
+     */
+    clientId;
+    /**
+     * The set of message handlers registered with this transport.
+     */
+    messageHandlers;
+    /**
+     * An array of message IDs that are waiting to be sent over the WebSocket connection.
+     * This builds up if the WebSocket is down for a period of time.
+     */
+    sendQueue;
+    /**
+     * The buffer of messages that have been sent but not yet acknowledged.
+     */
+    sendBuffer;
+    /**
+     * The map of {@link Connection}s managed by this transport.
+     */
+    connections;
+    /**
+     * Creates a new Transport instance.
+     * @param codec The codec used to encode and decode messages.
+     * @param clientId The client ID of this transport.
+     */
+    constructor(codec, clientId) {
+        this.messageHandlers = new Set();
+        this.sendBuffer = new Map();
+        this.sendQueue = new Map();
+        this.connections = new Map();
+        this.codec = codec;
+        this.clientId = clientId;
+        this.state = 'open';
+    }
+    /**
+     * The downstream implementation needs to call this when a new connection is established.
+     * @param conn The connection object.
+     */
+    onConnect(conn) {
+        log?.info(`${this.clientId} -- new connection to ${conn.connectedTo}`);
+        this.connections.set(conn.connectedTo, conn);
+        // send outstanding
+        const outstanding = this.sendQueue.get(conn.connectedTo);
+        if (!outstanding) {
+            return;
+        }
+        for (const id of outstanding) {
+            const msg = this.sendBuffer.get(id);
+            if (!msg) {
+                log?.warn(`${this.clientId} -- tried to resend a message we received an ack for`);
+                continue;
+            }
+            this.send(msg);
+        }
+        this.sendQueue.set(conn.connectedTo, []);
+    }
+    /**
+     * The downstream implementation needs to call this when a connection is closed.
+     * @param conn The connection object.
+     */
+    onDisconnect(conn) {
+        log?.info(`${this.clientId} -- disconnect from ${conn.connectedTo}`);
+        conn.close();
+        this.connections.delete(conn.connectedTo);
+    }
+    /**
+     * Handles a message received by this transport. Thin wrapper around {@link handleMsg} and {@link parseMsg}.
+     * @param msg The message to handle.
+     */
+    onMessage(msg) {
+        return this.handleMsg(this.parseMsg(msg));
+    }
+    /**
+     * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
+     * @param msg The message to parse.
+     * @returns The parsed message, or null if the message is malformed or invalid.
+     */
+    parseMsg(msg) {
+        const parsedMsg = this.codec.fromBuffer(msg);
+        if (parsedMsg === null) {
+            const decodedBuffer = new TextDecoder().decode(msg);
+            log?.warn(`${this.clientId} -- received malformed msg: ${decodedBuffer}`);
+            return null;
+        }
+        if (Value.Check(OpaqueTransportMessageSchema, parsedMsg)) {
+            return parsedMsg;
+        }
+        else {
+            log?.warn(`${this.clientId} -- received invalid msg: ${JSON.stringify(msg)}`);
+            return null;
+        }
+    }
+    /**
+     * Called when a message is received by this transport.
+     * You generally shouldn't need to override this in downstream transport implementations.
+     * @param msg The received message.
+     */
+    handleMsg(msg) {
+        if (!msg) {
+            return;
+        }
+        if (isAck(msg.controlFlags) && Value.Check(TransportAckSchema, msg)) {
+            // process ack
+            log?.info(`${this.clientId} -- received ack: ${JSON.stringify(msg)}`);
+            if (this.sendBuffer.has(msg.payload.ack)) {
+                this.sendBuffer.delete(msg.payload.ack);
+            }
+        }
+        else {
+            // regular river message
+            log?.info(`${this.clientId} -- received msg: ${JSON.stringify(msg)}`);
+            if (msg.to !== this.clientId) {
+                return;
+            }
+            for (const handler of this.messageHandlers) {
+                handler(msg);
+            }
+            if (!isAck(msg.controlFlags)) {
+                const ackMsg = reply(msg, { ack: msg.id });
+                ackMsg.controlFlags = 1 /* ControlFlags.AckBit */;
+                ackMsg.from = this.clientId;
+                this.send(ackMsg);
+            }
+        }
+    }
+    /**
+     * Adds a message listener to this transport.
+     * @param handler The message handler to add.
+     */
+    addMessageListener(handler) {
+        this.messageHandlers.add(handler);
+    }
+    /**
+     * Removes a message listener from this transport.
+     * @param handler The message handler to remove.
+     */
+    removeMessageListener(handler) {
+        this.messageHandlers.delete(handler);
+    }
+    /**
+     * Sends a message over this transport, delegating to the appropriate connection to actually
+     * send the message.
+     * @param msg The message to send.
+     * @returns The ID of the sent message.
+     */
+    send(msg) {
+        if (this.state === 'destroyed') {
+            const err = 'transport is destroyed, cant send';
+            log?.error(`${this.clientId} -- ` + err + `: ${JSON.stringify(msg)}`);
+            throw new Error(err);
+        }
+        else if (this.state === 'closed') {
+            log?.info(`${this.clientId} -- transport closed when sending, discarding : ${JSON.stringify(msg)}`);
+            return msg.id;
+        }
+        let conn = this.connections.get(msg.to);
+        // we only use sendBuffer to track messages that we expect an ack from,
+        // messages with the ack flag are not responded to
+        if (!isAck(msg.controlFlags)) {
+            this.sendBuffer.set(msg.id, msg);
+        }
+        if (conn) {
+            log?.info(`${this.clientId} -- sending ${JSON.stringify(msg)}`);
+            const ok = conn.send(this.codec.toBuffer(msg));
+            if (ok) {
+                return msg.id;
+            }
+        }
+        log?.info(`${this.clientId} -- connection to ${msg.to} not ready, attempting reconnect and queuing ${JSON.stringify(msg)}`);
+        const outstanding = this.sendQueue.get(msg.to) || [];
+        outstanding.push(msg.id);
+        this.sendQueue.set(msg.to, outstanding);
+        this.createNewConnection(msg.to);
+        return msg.id;
+    }
+    /**
+     * Default close implementation for transports. You should override this in the downstream
+     * implementation if you need to do any additional cleanup and call super.close() at the end.
+     * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
+     */
+    async close() {
+        for (const conn of this.connections.values()) {
+            conn.close();
+        }
+        this.connections.clear();
+        this.state = 'closed';
+        log?.info(`${this.clientId} -- closed transport`);
+    }
+    /**
+     * Default destroy implementation for transports. You should override this in the downstream
+     * implementation if you need to do any additional cleanup and call super.destroy() at the end.
+     * Destroys the transport. Any messages sent while the transport is destroyed will throw an error.
+     */
+    async destroy() {
+        for (const conn of this.connections.values()) {
+            conn.close();
+        }
+        this.connections.clear();
+        this.state = 'destroyed';
+        log?.info(`${this.clientId} -- destroyed transport`);
+    }
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@replit/river",
   "sideEffects": false,
   "description": "It's like tRPC but... with JSON Schema Support, duplex streaming and support for service multiplexing. Transport agnostic!",
-  "version": "0.6.4",
+  "version": "0.7.1",
   "type": "module",
   "exports": {
     ".": "./dist/router/index.js",
@@ -10,7 +10,8 @@
     "./codec": "./dist/codec/index.js",
     "./test-util": "./dist/testUtils.js",
     "./transport": "./dist/transport/index.js",
-    "./transport/ws": "./dist/transport/impls/ws.js",
+    "./transport/ws/client": "./dist/transport/impls/ws/client.js",
+    "./transport/ws/server": "./dist/transport/impls/ws/server.js",
     "./transport/stdio": "./dist/transport/impls/stdio.js"
   },
   "files": [
@@ -34,7 +35,7 @@
   "scripts": {
     "check": "tsc --noEmit && npx prettier . --check",
     "format": "npx prettier . --write",
-    "build": "tsc",
+    "build": "rm -rf ./dist && tsc",
     "prepack": "npm run build",
     "release": "npm publish --access public",
     "test": "vitest",

package/dist/__tests__/integration.test.d.ts

@@ -1,50 +0,0 @@
-export declare const EchoRequest: import("@sinclair/typebox").TObject<{
-    msg: import("@sinclair/typebox").TString;
-    ignore: import("@sinclair/typebox").TBoolean;
-}>;
-export declare const EchoResponse: import("@sinclair/typebox").TObject<{
-    response: import("@sinclair/typebox").TString;
-}>;
-export declare const TestServiceConstructor: () => {
-    name: "test";
-    state: {
-        count: number;
-    };
-    procedures: {
-        add: {
-            input: import("@sinclair/typebox").TObject<{
-                n: import("@sinclair/typebox").TNumber;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                result: import("@sinclair/typebox").TNumber;
-            }>;
-            handler: (context: import("../router").ServiceContextWithState<{
-                count: number;
-            }>, input: import("../transport/message").TransportMessage<{
-                n: number;
-            }>) => Promise<import("../transport/message").TransportMessage<{
-                result: number;
-            }>>;
-            type: "rpc";
-        };
-    } & {
-        echo: {
-            input: import("@sinclair/typebox").TObject<{
-                msg: import("@sinclair/typebox").TString;
-                ignore: import("@sinclair/typebox").TBoolean;
-            }>;
-            output: import("@sinclair/typebox").TObject<{
-                response: import("@sinclair/typebox").TString;
-            }>;
-            handler: (context: import("../router").ServiceContextWithState<{
-                count: number;
-            }>, input: AsyncIterable<import("../transport/message").TransportMessage<{
-                msg: string;
-                ignore: boolean;
-            }>>, output: import("it-pushable").Pushable<import("../transport/message").TransportMessage<{
-                response: string;
-            }>, void, unknown>) => Promise<void>;
-            type: "stream";
-        };
-    };
-};

package/dist/__tests__/integration.test.js

@@ -1,193 +0,0 @@
-import http from 'http';
-import { Type } from '@sinclair/typebox';
-import { ServiceBuilder, serializeService } from '../router/builder';
-import { reply } from '../transport/message';
-import { afterAll, describe, expect, test } from 'vitest';
-import { createWebSocketServer, createWsTransports, onServerReady, asClientRpc, asClientStream, } from '../testUtils';
-import { createServer } from '../router/server';
-import { createClient } from '../router/client';
-export const EchoRequest = Type.Object({
-    msg: Type.String(),
-    ignore: Type.Boolean(),
-});
-export const EchoResponse = Type.Object({ response: Type.String() });
-export const TestServiceConstructor = () => ServiceBuilder.create('test')
-    .initialState({
-    count: 0,
-})
-    .defineProcedure('add', {
-    type: 'rpc',
-    input: Type.Object({ n: Type.Number() }),
-    output: Type.Object({ result: Type.Number() }),
-    async handler(ctx, msg) {
-        const { n } = msg.payload;
-        ctx.state.count += n;
-        return reply(msg, { result: ctx.state.count });
-    },
-})
-    .defineProcedure('echo', {
-    type: 'stream',
-    input: EchoRequest,
-    output: EchoResponse,
-    async handler(_ctx, msgStream, returnStream) {
-        for await (const msg of msgStream) {
-            const req = msg.payload;
-            if (!req.ignore) {
-                returnStream.push(reply(msg, { response: req.msg }));
-            }
-        }
-    },
-})
-    .finalize();
-const OrderingServiceConstructor = () => ServiceBuilder.create('test')
-    .initialState({
-    msgs: [],
-})
-    .defineProcedure('add', {
-    type: 'rpc',
-    input: Type.Object({ n: Type.Number() }),
-    output: Type.Object({ ok: Type.Boolean() }),
-    async handler(ctx, msg) {
-        const { n } = msg.payload;
-        ctx.state.msgs.push(n);
-        return reply(msg, { ok: true });
-    },
-})
-    .defineProcedure('getAll', {
-    type: 'rpc',
-    input: Type.Object({}),
-    output: Type.Object({ msgs: Type.Array(Type.Number()) }),
-    async handler(ctx, msg) {
-        return reply(msg, { msgs: ctx.state.msgs });
-    },
-})
-    .finalize();
-test('serialize service to jsonschema', () => {
-    const service = TestServiceConstructor();
-    expect(serializeService(service)).toStrictEqual({
-        name: 'test',
-        state: { count: 0 },
-        procedures: {
-            add: {
-                input: {
-                    properties: {
-                        n: { type: 'number' },
-                    },
-                    required: ['n'],
-                    type: 'object',
-                },
-                output: {
-                    properties: {
-                        result: { type: 'number' },
-                    },
-                    required: ['result'],
-                    type: 'object',
-                },
-                type: 'rpc',
-            },
-            echo: {
-                input: {
-                    properties: {
-                        msg: { type: 'string' },
-                        ignore: { type: 'boolean' },
-                    },
-                    required: ['msg', 'ignore'],
-                    type: 'object',
-                },
-                output: {
-                    properties: {
-                        response: { type: 'string' },
-                    },
-                    required: ['response'],
-                    type: 'object',
-                },
-                type: 'stream',
-            },
-        },
-    });
-});
-describe('server-side test', () => {
-    const service = TestServiceConstructor();
-    const initialState = { count: 0 };
-    test('rpc basic', async () => {
-        const add = asClientRpc(initialState, service.procedures.add);
-        await expect(add({ n: 3 })).resolves.toStrictEqual({ result: 3 });
-    });
-    test('rpc initial state', async () => {
-        const add = asClientRpc({ count: 5 }, service.procedures.add);
-        await expect(add({ n: 6 })).resolves.toStrictEqual({ result: 11 });
-    });
-    test('stream basic', async () => {
-        const [input, output] = asClientStream(initialState, service.procedures.echo);
-        input.push({ msg: 'abc', ignore: false });
-        input.push({ msg: 'def', ignore: true });
-        input.push({ msg: 'ghi', ignore: false });
-        input.end();
-        await expect(output.next().then((res) => res.value)).resolves.toStrictEqual({
-            response: 'abc',
-        });
-        await expect(output.next().then((res) => res.value)).resolves.toStrictEqual({
-            response: 'ghi',
-        });
-        expect(output.readableLength).toBe(0);
-    });
-});
-describe('client <-> server integration test', async () => {
-    const server = http.createServer();
-    const port = await onServerReady(server);
-    const webSocketServer = await createWebSocketServer(server);
-    afterAll(() => {
-        webSocketServer.clients.forEach((socket) => {
-            socket.close();
-        });
-        server.close();
-    });
-    test('rpc', async () => {
-        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        await expect(client.test.add({ n: 3 })).resolves.toStrictEqual({
-            result: 3,
-        });
-    });
-    test('stream', async () => {
-        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
-        const serviceDefs = { test: TestServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        const [input, output, close] = await client.test.echo();
-        input.push({ msg: 'abc', ignore: false });
-        input.push({ msg: 'def', ignore: true });
-        input.push({ msg: 'ghi', ignore: false });
-        input.end();
-        await expect(output.next().then((res) => res.value)).resolves.toStrictEqual({
-            response: 'abc',
-        });
-        await expect(output.next().then((res) => res.value)).resolves.toStrictEqual({
-            response: 'ghi',
-        });
-        close();
-    });
-    test('message order is preserved in the face of disconnects', async () => {
-        const [clientTransport, serverTransport] = createWsTransports(port, webSocketServer);
-        const serviceDefs = { test: OrderingServiceConstructor() };
-        const server = await createServer(serverTransport, serviceDefs);
-        const client = createClient(clientTransport);
-        const expected = [];
-        for (let i = 0; i < 50; i++) {
-            expected.push(i);
-            if (i == 10) {
-                clientTransport.ws?.close();
-            }
-            if (i == 42) {
-                clientTransport.ws?.terminate();
-            }
-            await client.test.add({
-                n: i,
-            });
-        }
-        const res = await client.test.getAll({});
-        return expect(res.msgs).toStrictEqual(expected);
-    });
-});

package/dist/transport/impls/stdio.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../../transport/impls/stdio.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAGrC,UAAU,OAAO;IACf,KAAK,EAAE,KAAK,CAAC;CACd;AAQD;;;GAGG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC3C;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC,cAAc,CAAC;IAC7B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAE9B;;;;;OAKG;gBAED,QAAQ,EAAE,iBAAiB,EAC3B,KAAK,GAAE,MAAM,CAAC,cAA8B,EAC5C,MAAM,GAAE,MAAM,CAAC,cAA+B,EAC9C,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAcpC;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,MAAM;IAWzC;;OAEG;IACG,KAAK;CACZ"}

package/dist/transport/impls/stdio.js

@@ -1,56 +0,0 @@
-import { NaiveJsonCodec } from '../../codec/json';
-import { Transport } from '../types';
-import readline from 'readline';
-const defaultOptions = {
-    codec: NaiveJsonCodec,
-};
-const newlineBuff = new TextEncoder().encode('\n');
-/**
- * A transport implementation that uses standard input and output streams.
- * @extends Transport
- */
-export class StdioTransport extends Transport {
-    /**
-     * The readable stream to use as input.
-     */
-    input;
-    /**
-     * The writable stream to use as output.
-     */
-    output;
-    /**
-     * Constructs a new StdioTransport instance.
-     * @param clientId - The ID of the client associated with this transport.
-     * @param input - The readable stream to use as input. Defaults to process.stdin.
-     * @param output - The writable stream to use as output. Defaults to process.stdout.
-     */
-    constructor(clientId, input = process.stdin, output = process.stdout, providedOptions) {
-        const options = { ...defaultOptions, ...providedOptions };
-        super(options.codec, clientId);
-        this.input = input;
-        this.output = output;
-        const rl = readline.createInterface({
-            input: this.input,
-        });
-        const encoder = new TextEncoder();
-        rl.on('line', (msg) => this.onMessage(encoder.encode(msg)));
-    }
-    /**
-     * Sends a message over the transport.
-     * @param msg - The message to send.
-     * @returns The ID of the sent message.
-     */
-    send(msg) {
-        const id = msg.id;
-        const payload = this.codec.toBuffer(msg);
-        const out = new Uint8Array(payload.length + newlineBuff.length);
-        out.set(payload, 0);
-        out.set(newlineBuff, payload.length);
-        this.output.write(out);
-        return id;
-    }
-    /**
-     * Closes the transport.
-     */
-    async close() { }
-}

package/dist/transport/impls/stdio.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stdio.test.d.ts","sourceRoot":"","sources":["../../../transport/impls/stdio.test.ts"],"names":[],"mappings":""}

package/dist/transport/impls/ws.d.ts

@@ -1,71 +0,0 @@
-/// <reference types="ws" />
-import WebSocket from 'isomorphic-ws';
-import { Transport } from '../types';
-import { MessageId, OpaqueTransportMessage, TransportClientId } from '../message';
-import { type Codec } from '../../codec';
-interface Options {
-    retryIntervalMs: number;
-    codec: Codec;
-    binaryType: 'arraybuffer' | 'blob';
-}
-type WebSocketResult = {
-    ws: WebSocket;
-} | {
-    err: string;
-};
-/**
- * A transport implementation that uses a WebSocket connection with automatic reconnection.
- * @class
- * @extends Transport
- */
-export declare class WebSocketTransport extends Transport {
-    /**
-     * A function that returns a Promise that resolves to a WebSocket instance.
-     */
-    wsGetter: () => Promise<WebSocket>;
-    ws?: WebSocket;
-    options: Options;
-    /**
-     * A flag indicating whether the transport has been destroyed.
-     * A destroyed transport will not attempt to reconnect and cannot be used again.
-     */
-    state: 'open' | 'closed' | 'destroyed';
-    /**
-     * An ongoing reconnect attempt if it exists. When the attempt finishes, it contains a
-     * {@link WebSocketResult} object when a connection is established or an error occurs.
-     */
-    reconnectPromise?: Promise<WebSocketResult>;
-    /**
-     * An array of message IDs that are waiting to be sent over the WebSocket connection.
-     * This builds up if the WebSocket is down for a period of time.
-     */
-    sendQueue: Array<MessageId>;
-    /**
-     * Creates a new WebSocketTransport instance.
-     * @param wsGetter A function that returns a Promise that resolves to a WebSocket instance.
-     * @param clientId The ID of the client using the transport.
-     * @param providedOptions An optional object containing configuration options for the transport.
-     */
-    constructor(wsGetter: () => Promise<WebSocket>, clientId: TransportClientId, providedOptions?: Partial<Options>);
-    /**
-     * Begins a new attempt to establish a WebSocket connection.
-     */
-    private tryConnect;
-    /**
-     * Sends a message over the WebSocket connection. If the WebSocket connection is
-     * not healthy, it will queue until the connection is successful.
-     * @param msg The message to send.
-     * @returns The ID of the sent message.
-     */
-    send(msg: OpaqueTransportMessage): MessageId;
-    /**
-     * Closes the WebSocket transport. Any messages sent while the transport is closed will be silently discarded.
-     */
-    close(): Promise<void | undefined>;
-    /**
-     * Destroys the WebSocket transport. Any messages sent while the transport is closed will throw an error.
-     */
-    destroy(): Promise<void | undefined>;
-}
-export {};
-//# sourceMappingURL=ws.d.ts.map

package/dist/transport/impls/ws.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ws.d.ts","sourceRoot":"","sources":["../../../transport/impls/ws.ts"],"names":[],"mappings":";AAAA,OAAO,SAAS,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAErC,OAAO,EACL,SAAS,EACT,sBAAsB,EACtB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,UAAU,OAAO;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC;IACb,UAAU,EAAE,aAAa,GAAG,MAAM,CAAC;CACpC;AAQD,KAAK,eAAe,GAAG;IAAE,EAAE,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C;;OAEG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,CAAC;IACnC,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;IAEvC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAE5C;;;OAGG;IACH,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAE5B;;;;;OAKG;gBAED,QAAQ,EAAE,MAAM,OAAO,CAAC,SAAS,CAAC,EAClC,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAWpC;;OAEG;YACW,UAAU;IAuExB;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,sBAAsB,GAAG,SAAS;IA4B5C;;OAEG;IACG,KAAK;IAMX;;OAEG;IACG,OAAO;CAKd"}