@trpc/client 11.0.0-rc.772 → 11.0.0-rc.781

package/dist/links/wsLink/wsClient/requestManager.js

@@ -0,0 +1,138 @@
+'use strict';
+
+var utils = require('./utils.js');
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Manages WebSocket requests, tracking their lifecycle and providing utility methods
+ * for handling outgoing and pending requests.
+ *
+ * - **Outgoing requests**: Requests that are queued and waiting to be sent.
+ * - **Pending requests**: Requests that have been sent and are in flight awaiting a response.
+ *   For subscriptions, multiple responses may be received until the subscription is closed.
+ */ class RequestManager {
+    /**
+   * Registers a new request by adding it to the outgoing queue and setting up
+   * callbacks for lifecycle events such as completion or error.
+   *
+   * @param message - The outgoing message to be sent.
+   * @param callbacks - Callback functions to observe the request's state.
+   * @returns A cleanup function to manually remove the request.
+   */ register(message, callbacks) {
+        const { promise: end, resolve } = utils.withResolvers();
+        this.outgoingRequests.push({
+            id: String(message.id),
+            message,
+            end,
+            callbacks: {
+                next: callbacks.next,
+                complete: ()=>{
+                    callbacks.complete();
+                    resolve();
+                },
+                error: (e)=>{
+                    callbacks.error(e);
+                    resolve();
+                }
+            }
+        });
+        return ()=>{
+            this.delete(message.id);
+            callbacks.complete();
+            resolve();
+        };
+    }
+    /**
+   * Deletes a request from both the outgoing and pending collections, if it exists.
+   */ delete(messageId) {
+        if (messageId === null) return;
+        this.outgoingRequests = this.outgoingRequests.filter(({ id })=>id !== String(messageId));
+        delete this.pendingRequests[String(messageId)];
+    }
+    /**
+   * Moves all outgoing requests to the pending state and clears the outgoing queue.
+   *
+   * The caller is expected to handle the actual sending of the requests
+   * (e.g., sending them over the network) after this method is called.
+   *
+   * @returns The list of requests that were transitioned to the pending state.
+   */ flush() {
+        const requests = this.outgoingRequests;
+        this.outgoingRequests = [];
+        for (const request of requests){
+            this.pendingRequests[request.id] = request;
+        }
+        return requests;
+    }
+    /**
+   * Retrieves all currently pending requests, which are in flight awaiting responses
+   * or handling ongoing subscriptions.
+   */ getPendingRequests() {
+        return Object.values(this.pendingRequests);
+    }
+    /**
+   * Retrieves a specific pending request by its message ID.
+   */ getPendingRequest(messageId) {
+        if (messageId === null) return null;
+        return this.pendingRequests[String(messageId)];
+    }
+    /**
+   * Retrieves all outgoing requests, which are waiting to be sent.
+   */ getOutgoingRequests() {
+        return this.outgoingRequests;
+    }
+    /**
+   * Retrieves all requests, both outgoing and pending, with their respective states.
+   *
+   * @returns An array of all requests with their state ("outgoing" or "pending").
+   */ getRequests() {
+        return [
+            ...this.getOutgoingRequests().map((request)=>({
+                    state: 'outgoing',
+                    message: request.message,
+                    end: request.end,
+                    callbacks: request.callbacks
+                })),
+            ...this.getPendingRequests().map((request)=>({
+                    state: 'pending',
+                    message: request.message,
+                    end: request.end,
+                    callbacks: request.callbacks
+                }))
+        ];
+    }
+    /**
+   * Checks if there are any pending requests, including ongoing subscriptions.
+   */ hasPendingRequests() {
+        return this.getPendingRequests().length > 0;
+    }
+    /**
+   * Checks if there are any outgoing requests waiting to be sent.
+   */ hasOutgoingRequests() {
+        return this.outgoingRequests.length > 0;
+    }
+    constructor(){
+        /**
+   * Stores requests that are outgoing, meaning they are registered but not yet sent over the WebSocket.
+   */ _define_property(this, "outgoingRequests", new Array());
+        /**
+   * Stores requests that are pending (in flight), meaning they have been sent over the WebSocket
+   * and are awaiting responses. For subscriptions, this includes requests
+   * that may receive multiple responses.
+   */ _define_property(this, "pendingRequests", {});
+    }
+}
+
+exports.RequestManager = RequestManager;

package/dist/links/wsLink/wsClient/requestManager.mjs

@@ -0,0 +1,136 @@
+import { withResolvers } from './utils.mjs';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+/**
+ * Manages WebSocket requests, tracking their lifecycle and providing utility methods
+ * for handling outgoing and pending requests.
+ *
+ * - **Outgoing requests**: Requests that are queued and waiting to be sent.
+ * - **Pending requests**: Requests that have been sent and are in flight awaiting a response.
+ *   For subscriptions, multiple responses may be received until the subscription is closed.
+ */ class RequestManager {
+    /**
+   * Registers a new request by adding it to the outgoing queue and setting up
+   * callbacks for lifecycle events such as completion or error.
+   *
+   * @param message - The outgoing message to be sent.
+   * @param callbacks - Callback functions to observe the request's state.
+   * @returns A cleanup function to manually remove the request.
+   */ register(message, callbacks) {
+        const { promise: end, resolve } = withResolvers();
+        this.outgoingRequests.push({
+            id: String(message.id),
+            message,
+            end,
+            callbacks: {
+                next: callbacks.next,
+                complete: ()=>{
+                    callbacks.complete();
+                    resolve();
+                },
+                error: (e)=>{
+                    callbacks.error(e);
+                    resolve();
+                }
+            }
+        });
+        return ()=>{
+            this.delete(message.id);
+            callbacks.complete();
+            resolve();
+        };
+    }
+    /**
+   * Deletes a request from both the outgoing and pending collections, if it exists.
+   */ delete(messageId) {
+        if (messageId === null) return;
+        this.outgoingRequests = this.outgoingRequests.filter(({ id })=>id !== String(messageId));
+        delete this.pendingRequests[String(messageId)];
+    }
+    /**
+   * Moves all outgoing requests to the pending state and clears the outgoing queue.
+   *
+   * The caller is expected to handle the actual sending of the requests
+   * (e.g., sending them over the network) after this method is called.
+   *
+   * @returns The list of requests that were transitioned to the pending state.
+   */ flush() {
+        const requests = this.outgoingRequests;
+        this.outgoingRequests = [];
+        for (const request of requests){
+            this.pendingRequests[request.id] = request;
+        }
+        return requests;
+    }
+    /**
+   * Retrieves all currently pending requests, which are in flight awaiting responses
+   * or handling ongoing subscriptions.
+   */ getPendingRequests() {
+        return Object.values(this.pendingRequests);
+    }
+    /**
+   * Retrieves a specific pending request by its message ID.
+   */ getPendingRequest(messageId) {
+        if (messageId === null) return null;
+        return this.pendingRequests[String(messageId)];
+    }
+    /**
+   * Retrieves all outgoing requests, which are waiting to be sent.
+   */ getOutgoingRequests() {
+        return this.outgoingRequests;
+    }
+    /**
+   * Retrieves all requests, both outgoing and pending, with their respective states.
+   *
+   * @returns An array of all requests with their state ("outgoing" or "pending").
+   */ getRequests() {
+        return [
+            ...this.getOutgoingRequests().map((request)=>({
+                    state: 'outgoing',
+                    message: request.message,
+                    end: request.end,
+                    callbacks: request.callbacks
+                })),
+            ...this.getPendingRequests().map((request)=>({
+                    state: 'pending',
+                    message: request.message,
+                    end: request.end,
+                    callbacks: request.callbacks
+                }))
+        ];
+    }
+    /**
+   * Checks if there are any pending requests, including ongoing subscriptions.
+   */ hasPendingRequests() {
+        return this.getPendingRequests().length > 0;
+    }
+    /**
+   * Checks if there are any outgoing requests waiting to be sent.
+   */ hasOutgoingRequests() {
+        return this.outgoingRequests.length > 0;
+    }
+    constructor(){
+        /**
+   * Stores requests that are outgoing, meaning they are registered but not yet sent over the WebSocket.
+   */ _define_property(this, "outgoingRequests", new Array());
+        /**
+   * Stores requests that are pending (in flight), meaning they have been sent over the WebSocket
+   * and are awaiting responses. For subscriptions, this includes requests
+   * that may receive multiple responses.
+   */ _define_property(this, "pendingRequests", {});
+    }
+}
+
+export { RequestManager };

package/dist/links/wsLink/wsClient/utils.d.ts

@@ -0,0 +1,38 @@
+import type { TRPCRequestInfo } from '@trpc/server/unstable-core-do-not-import';
+import type { CallbackOrValue, UrlOptionsWithConnectionParams } from '../../internals/urlWithConnectionParams';
+export declare class TRPCWebSocketClosedError extends Error {
+    constructor(opts: {
+        message: string;
+        cause?: unknown;
+    });
+}
+/**
+ * Utility class for managing a timeout that can be started, stopped, and reset.
+ * Useful for scenarios where the timeout duration is reset dynamically based on events.
+ */
+export declare class ResettableTimeout {
+    private readonly onTimeout;
+    private readonly timeoutMs;
+    private timeout;
+    constructor(onTimeout: () => void, timeoutMs: number);
+    /**
+     * Resets the current timeout, restarting it with the same duration.
+     * Does nothing if no timeout is active.
+     */
+    reset(): void;
+    start(): void;
+    stop(): void;
+}
+export declare function withResolvers<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+/**
+ * Resolves a WebSocket URL and optionally appends connection parameters.
+ *
+ * If connectionParams are provided, appends 'connectionParams=1' query parameter.
+ */
+export declare function prepareUrl(urlOptions: UrlOptionsWithConnectionParams): Promise<string>;
+export declare function buildConnectionMessage(connectionParams: CallbackOrValue<TRPCRequestInfo['connectionParams']>): Promise<string>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/links/wsLink/wsClient/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/links/wsLink/wsClient/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,eAAe,EAChB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,EACV,eAAe,EACf,8BAA8B,EAC/B,MAAM,yCAAyC,CAAC;AAGjD,qBAAa,wBAAyB,SAAQ,KAAK;gBACrC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAOvD;AAED;;;GAGG;AACH,qBAAa,iBAAiB;IAI1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAJ5B,OAAO,CAAC,OAAO,CAA4C;gBAGxC,SAAS,EAAE,MAAM,IAAI,EACrB,SAAS,EAAE,MAAM;IAGpC;;;OAGG;IACI,KAAK;IAOL,KAAK;IAKL,IAAI;CAIZ;AAGD,wBAAgB,aAAa,CAAC,CAAC;;qBACR,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI;sBAC1B,GAAG,KAAK,IAAI;EAQnC;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,UAAU,EAAE,8BAA8B,mBAU1E;AAED,wBAAsB,sBAAsB,CAC1C,gBAAgB,EAAE,eAAe,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC,mBAQvE"}

package/dist/links/wsLink/wsClient/utils.js

@@ -0,0 +1,94 @@
+'use strict';
+
+var urlWithConnectionParams = require('../../internals/urlWithConnectionParams.js');
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class TRPCWebSocketClosedError extends Error {
+    constructor(opts){
+        super(opts.message, {
+            cause: opts.cause
+        });
+        this.name = 'TRPCWebSocketClosedError';
+        Object.setPrototypeOf(this, TRPCWebSocketClosedError.prototype);
+    }
+}
+/**
+ * Utility class for managing a timeout that can be started, stopped, and reset.
+ * Useful for scenarios where the timeout duration is reset dynamically based on events.
+ */ class ResettableTimeout {
+    /**
+   * Resets the current timeout, restarting it with the same duration.
+   * Does nothing if no timeout is active.
+   */ reset() {
+        if (!this.timeout) return;
+        clearTimeout(this.timeout);
+        this.timeout = setTimeout(this.onTimeout, this.timeoutMs);
+    }
+    start() {
+        clearTimeout(this.timeout);
+        this.timeout = setTimeout(this.onTimeout, this.timeoutMs);
+    }
+    stop() {
+        clearTimeout(this.timeout);
+        this.timeout = undefined;
+    }
+    constructor(onTimeout, timeoutMs){
+        _define_property(this, "onTimeout", void 0);
+        _define_property(this, "timeoutMs", void 0);
+        _define_property(this, "timeout", void 0);
+        this.onTimeout = onTimeout;
+        this.timeoutMs = timeoutMs;
+    }
+}
+// Ponyfill for Promise.withResolvers https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
+function withResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return {
+        promise,
+        resolve: resolve,
+        reject: reject
+    };
+}
+/**
+ * Resolves a WebSocket URL and optionally appends connection parameters.
+ *
+ * If connectionParams are provided, appends 'connectionParams=1' query parameter.
+ */ async function prepareUrl(urlOptions) {
+    const url = await urlWithConnectionParams.resultOf(urlOptions.url);
+    if (!urlOptions.connectionParams) return url;
+    // append `?connectionParams=1` when connection params are used
+    const prefix = url.includes('?') ? '&' : '?';
+    const connectionParams = `${prefix}connectionParams=1`;
+    return url + connectionParams;
+}
+async function buildConnectionMessage(connectionParams) {
+    const message = {
+        method: 'connectionParams',
+        data: await urlWithConnectionParams.resultOf(connectionParams)
+    };
+    return JSON.stringify(message);
+}
+
+exports.ResettableTimeout = ResettableTimeout;
+exports.TRPCWebSocketClosedError = TRPCWebSocketClosedError;
+exports.buildConnectionMessage = buildConnectionMessage;
+exports.prepareUrl = prepareUrl;
+exports.withResolvers = withResolvers;

package/dist/links/wsLink/wsClient/utils.mjs

@@ -0,0 +1,88 @@
+import { resultOf } from '../../internals/urlWithConnectionParams.mjs';
+
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class TRPCWebSocketClosedError extends Error {
+    constructor(opts){
+        super(opts.message, {
+            cause: opts.cause
+        });
+        this.name = 'TRPCWebSocketClosedError';
+        Object.setPrototypeOf(this, TRPCWebSocketClosedError.prototype);
+    }
+}
+/**
+ * Utility class for managing a timeout that can be started, stopped, and reset.
+ * Useful for scenarios where the timeout duration is reset dynamically based on events.
+ */ class ResettableTimeout {
+    /**
+   * Resets the current timeout, restarting it with the same duration.
+   * Does nothing if no timeout is active.
+   */ reset() {
+        if (!this.timeout) return;
+        clearTimeout(this.timeout);
+        this.timeout = setTimeout(this.onTimeout, this.timeoutMs);
+    }
+    start() {
+        clearTimeout(this.timeout);
+        this.timeout = setTimeout(this.onTimeout, this.timeoutMs);
+    }
+    stop() {
+        clearTimeout(this.timeout);
+        this.timeout = undefined;
+    }
+    constructor(onTimeout, timeoutMs){
+        _define_property(this, "onTimeout", void 0);
+        _define_property(this, "timeoutMs", void 0);
+        _define_property(this, "timeout", void 0);
+        this.onTimeout = onTimeout;
+        this.timeoutMs = timeoutMs;
+    }
+}
+// Ponyfill for Promise.withResolvers https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
+function withResolvers() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return {
+        promise,
+        resolve: resolve,
+        reject: reject
+    };
+}
+/**
+ * Resolves a WebSocket URL and optionally appends connection parameters.
+ *
+ * If connectionParams are provided, appends 'connectionParams=1' query parameter.
+ */ async function prepareUrl(urlOptions) {
+    const url = await resultOf(urlOptions.url);
+    if (!urlOptions.connectionParams) return url;
+    // append `?connectionParams=1` when connection params are used
+    const prefix = url.includes('?') ? '&' : '?';
+    const connectionParams = `${prefix}connectionParams=1`;
+    return url + connectionParams;
+}
+async function buildConnectionMessage(connectionParams) {
+    const message = {
+        method: 'connectionParams',
+        data: await resultOf(connectionParams)
+    };
+    return JSON.stringify(message);
+}
+
+export { ResettableTimeout, TRPCWebSocketClosedError, buildConnectionMessage, prepareUrl, withResolvers };

package/dist/links/wsLink/wsClient/wsClient.d.ts

@@ -0,0 +1,85 @@
+import type { AnyTRPCRouter } from '@trpc/server';
+import type { BehaviorSubject } from '@trpc/server/observable';
+import type { CombinedDataTransformer } from '@trpc/server/unstable-core-do-not-import';
+import { TRPCClientError } from '../../../TRPCClientError';
+import type { TRPCConnectionState } from '../../internals/subscriptions';
+import type { Operation, OperationResultEnvelope } from '../../types';
+import type { WebSocketClientOptions } from './options';
+/**
+ * A WebSocket client for managing TRPC operations, supporting lazy initialization,
+ * reconnection, keep-alive, and request management.
+ */
+export declare class WsClient {
+    /**
+     * Observable tracking the current connection state, including errors.
+     */
+    readonly connectionState: BehaviorSubject<TRPCConnectionState<TRPCClientError<AnyTRPCRouter>>>;
+    private allowReconnect;
+    private requestManager;
+    private readonly activeConnection;
+    private readonly reconnectRetryDelay;
+    private inactivityTimeout;
+    private readonly callbacks;
+    private readonly connectionParams;
+    private readonly lazyMode;
+    constructor(opts: WebSocketClientOptions);
+    /**
+     * Opens the WebSocket connection. Handles reconnection attempts and updates
+     * the connection state accordingly.
+     */
+    private open;
+    /**
+     * Closes the WebSocket connection and stops managing requests.
+     * Ensures all outgoing and pending requests are properly finalized.
+     */
+    close(): Promise<void>;
+    /**
+     * Method to request the server.
+     * Handles data transformation, batching of requests, and subscription lifecycle.
+     *
+     * @param op - The operation details including id, type, path, input and signal
+     * @param transformer - Data transformer for serializing requests and deserializing responses
+     * @param lastEventId - Optional ID of the last received event for subscriptions
+     *
+     * @returns An observable that emits operation results and handles cleanup
+     */
+    request({ op: { id, type, path, input, signal }, transformer, lastEventId, }: {
+        op: Pick<Operation, 'id' | 'type' | 'path' | 'input' | 'signal'>;
+        transformer: CombinedDataTransformer;
+        lastEventId?: string;
+    }): import("@trpc/server/observable").Observable<OperationResultEnvelope<unknown, TRPCClientError<AnyTRPCRouter>>, TRPCClientError<AnyTRPCRouter>>;
+    get connection(): {
+        readonly id: number;
+        readonly state: "open";
+        readonly ws: WebSocket;
+    } | {
+        readonly id: number;
+        readonly state: "closed";
+        readonly ws: WebSocket;
+    } | {
+        readonly id: number;
+        readonly state: "connecting";
+        readonly ws: WebSocket;
+    } | null;
+    /**
+     * Manages the reconnection process for the WebSocket using retry logic.
+     * Ensures that only one reconnection attempt is active at a time by tracking the current
+     * reconnection state in the `reconnecting` promise.
+     */
+    private reconnecting;
+    private reconnect;
+    private setupWebSocketListeners;
+    private handleResponseMessage;
+    private handleIncomingRequest;
+    /**
+     * Sends a message or batch of messages directly to the server.
+     */
+    private send;
+    /**
+     * Groups requests for batch sending.
+     *
+     * @returns A function to abort the batched request.
+     */
+    private batchSend;
+}
+//# sourceMappingURL=wsClient.d.ts.map

package/dist/links/wsLink/wsClient/wsClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsClient.d.ts","sourceRoot":"","sources":["../../../../src/links/wsLink/wsClient/wsClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,KAAK,EACV,uBAAuB,EAKxB,MAAM,0CAA0C,CAAC;AAMlD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAWxD;;;GAGG;AACH,qBAAa,QAAQ;IACnB;;OAEG;IACH,SAAgB,eAAe,EAAE,eAAe,CAC9C,mBAAmB,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CACpD,CAAC;IAEF,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAe;IAChD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAmC;IACvE,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAGxB;IACF,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA6C;IAC9E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;gBAEvB,IAAI,EAAE,sBAAsB;IA4DxC;;;OAGG;YACW,IAAI;IAuBlB;;;OAGG;IACU,KAAK;IA+BlB;;;;;;;;;OASG;IACI,OAAO,CAAC,EACb,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EACrC,WAAW,EACX,WAAW,GACZ,EAAE;QACD,EAAE,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC,CAAC;QACjE,WAAW,EAAE,uBAAuB,CAAC;QACrC,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB;IA+CD,IAAW,UAAU;;;;;;;;;;;;aAEpB;IAED;;;;OAIG;IACH,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,SAAS;IAwBjB,OAAO,CAAC,uBAAuB;IA0F/B,OAAO,CAAC,qBAAqB;IAuB7B,OAAO,CAAC,qBAAqB;IAU7B;;OAEG;IACH,OAAO,CAAC,IAAI;IAgBZ;;;;OAIG;IACH,OAAO,CAAC,SAAS;CAmBlB"}