@flowcore/pathways 0.16.4 → 0.17.0

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/data-pump.js

@@ -0,0 +1,501 @@
+import { utc } from "@date-fns/utc";
+import { TimeUuid } from "../../../../time-uuid/0.1.2/src/mod.js";
+import { format, startOfHour } from "date-fns";
+import { FlowcoreDataSource } from "./data-source.js";
+import { metrics } from "./metrics.js";
+import { FlowcoreNotifier } from "./notifier.js";
+export class FlowcoreDataPump {
+    constructor(dataSource, notifier, stateManager, options, logger) {
+        Object.defineProperty(this, "dataSource", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: dataSource
+        });
+        Object.defineProperty(this, "notifier", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: notifier
+        });
+        Object.defineProperty(this, "stateManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: stateManager
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(this, "logger", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: logger
+        });
+        Object.defineProperty(this, "nextCursor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "running", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "restartTo", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "abortController", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "buffer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "bufferState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stopAtState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "isLive", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "finallyFailedHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // #endregion
+        // #region Waiters
+        Object.defineProperty(this, "waiterEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "waiterBufferThreshold", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "waiterBufferEmpty", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.bufferState = {
+            timeBucket: format(startOfHour(utc(new Date())), "yyyyMMddHH0000"),
+            eventId: TimeUuid.now().toString(),
+        };
+    }
+    get isRunning() {
+        return this.running;
+    }
+    static create(options, dataSourceOverride) {
+        if ("apiKey" in options.auth && !options.auth.apiKeyId) {
+            const parts = options.auth.apiKey.split("_");
+            if (parts.length !== 3 || parts[0] !== "fc") {
+                throw new Error("Invalid API key");
+            }
+            options.auth.apiKeyId = parts[1];
+        }
+        const dataSource = dataSourceOverride ?? new FlowcoreDataSource({
+            auth: options.auth,
+            dataSource: options.dataSource,
+            baseUrlOverride: options.baseUrlOverride,
+            noTranslation: options.noTranslation,
+            directMode: options.directMode,
+        });
+        const notifier = new FlowcoreNotifier({
+            auth: options.auth,
+            dataSource: options.dataSource,
+            natsServers: options.notifier?.type === "nats" ? options.notifier.servers : undefined,
+            pollerIntervalMs: options.notifier?.type === "poller" ? options.notifier.intervalMs : undefined,
+            logger: options.logger,
+            directMode: options.directMode,
+            noTranslation: options.noTranslation,
+        });
+        return new FlowcoreDataPump(dataSource, notifier, options.stateManager, {
+            bufferSize: options.bufferSize ?? 1000,
+            bufferThreshold: Math.ceil((options.bufferSize ?? 1000) * 0.1),
+            maxRedeliveryCount: options.maxRedeliveryCount ?? 3,
+            achknowledgeTimeoutMs: options.achknowledgeTimeoutMs ?? 5_000,
+            includeSensitiveData: options.includeSensitiveData ?? false,
+            processor: options.processor,
+            stopAt: options.stopAt,
+        }, options.logger);
+    }
+    async start(callback) {
+        this.isLive = false;
+        if (this.running) {
+            throw new Error("Data pump already running");
+        }
+        this.running = true;
+        this.nextCursor = undefined;
+        this.updateMetricsGauges();
+        const currentState = await this.stateManager.getState();
+        const timeBucket = currentState
+            ? await this.dataSource.getClosestTimeBucket(currentState.timeBucket)
+            : format(startOfHour(utc(new Date())), "yyyyMMddHH0000");
+        this.bufferState = {
+            timeBucket: timeBucket ?? format(startOfHour(utc(new Date())), "yyyyMMddHH0000"),
+            eventId: currentState ? currentState.eventId : TimeUuid.now().toString(),
+        };
+        if (this.options.stopAt) {
+            this.stopAtState = {
+                timeBucket: (await this.dataSource.getClosestTimeBucket(format(startOfHour(utc(this.options.stopAt)), "yyyyMMddHH0000"), true)) ?? format(startOfHour(utc(new Date())), "yyyyMMddHH0000"),
+                eventId: TimeUuid.fromDate(this.options.stopAt).toString(),
+            };
+        }
+        if (this.options.processor) {
+            this.processLoop().catch((error) => {
+                this.logger?.error("Error in processor", { error });
+                this.stop();
+            });
+        }
+        if (!callback) {
+            return this.loop();
+        }
+        void this.loop()
+            .then(() => callback())
+            .catch((error) => callback(error));
+    }
+    restart(state, stopAt) {
+        this.restartTo = state;
+        if (stopAt !== undefined) {
+            this.options.stopAt = stopAt ?? undefined;
+        }
+        this.stop(true);
+    }
+    stop(isRestart = false) {
+        this.running = false;
+        this.buffer = [];
+        this.updateMetricsGauges();
+        this.abortController?.abort();
+        this.waiterBufferThreshold?.();
+        if (!isRestart) {
+            this.waiterEvents?.();
+        }
+    }
+    updateState(eventId) {
+        if (!this.stateManager.setState) {
+            return;
+        }
+        const stateEventId = eventId ?? this.buffer[0]?.event.eventId;
+        if (!stateEventId) {
+            return;
+        }
+        const date = TimeUuid.fromString(stateEventId).getDate();
+        const timeBucket = format(startOfHour(utc(date)), "yyyyMMddHH0000");
+        return this.stateManager.setState?.({ timeBucket, eventId: stateEventId });
+    }
+    async loop() {
+        do {
+            const amountToFetch = this.options.bufferSize - this.buffer.length;
+            if (amountToFetch <= 0) {
+                this.logger?.info("Buffer is full, waiting for space");
+                await this.waitForBufferThreshold();
+                continue;
+            }
+            this.logger?.debug(`fetching ${amountToFetch} events from ${this.bufferState.timeBucket}(${this.nextCursor})`);
+            const { events, nextCursor } = await this.dataSource.getEvents(this.bufferState, amountToFetch, this.stopAtState?.eventId, this.nextCursor, this.options.includeSensitiveData);
+            if (!this.running) {
+                break;
+            }
+            this.logger?.debug(`fetched ${events.length} events`);
+            this.buffer.push(...events.map((event) => ({ event, status: "open", deliveryCount: 0 })));
+            this.nextCursor = nextCursor;
+            this.updateMetricsGauges();
+            events.length && this.waiterEvents?.();
+            this.bufferState.eventId = events[events.length - 1]?.eventId ?? this.bufferState.eventId;
+            if (this.stopAtState?.timeBucket && this.bufferState.timeBucket >= this.stopAtState.timeBucket && !events.length) {
+                this.logger?.info("Stopping at stopAt state");
+                await this.waitForBufferEmpty();
+                this.stop();
+                break;
+            }
+            if (!this.nextCursor) {
+                const timeBucket = await this.dataSource.getNextTimeBucket(this.bufferState.timeBucket);
+                if (!this.running) {
+                    break;
+                }
+                if (timeBucket) {
+                    this.bufferState.timeBucket = timeBucket;
+                }
+                else {
+                    const previousTimeBucket = this.bufferState.timeBucket;
+                    this.bufferState.timeBucket = format(startOfHour(utc(new Date())), "yyyyMMddHH0000");
+                    if (previousTimeBucket === this.bufferState.timeBucket && !events.length) {
+                        this.isLive = true;
+                        this.logger?.debug("Going live...");
+                        this.abortController = new AbortController();
+                        await this.notifier.wait(this.abortController.signal);
+                    }
+                    else if (this.isLive) {
+                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                    }
+                }
+            }
+        } while (this.running);
+        if (this.restartTo) {
+            await this.dataSource.getTimeBuckets(true);
+            this.restartTo.timeBucket = (await this.dataSource.getClosestTimeBucket(this.restartTo.timeBucket)) ??
+                format(startOfHour(utc(new Date())), "yyyyMMddHH0000");
+            this.nextCursor = undefined;
+            this.bufferState = this.restartTo;
+            this.restartTo = undefined;
+            this.running = true;
+            return this.loop();
+        }
+        this.logger?.info("Data pump stopped");
+    }
+    // #region Puller
+    async reserve(amount) {
+        if (!this.running) {
+            return [];
+        }
+        const events = [];
+        const deliveryId = crypto.randomUUID();
+        for (const event of this.buffer) {
+            if (event.status === "open") {
+                event.status = "reserved";
+                event.deliveryId = deliveryId;
+                event.deliveryCount++;
+                events.push(event.event);
+                this.incMetricsCounter("pulled", event.event.eventType, JSON.stringify(event.event).length);
+                if (events.length === amount) {
+                    break;
+                }
+            }
+        }
+        if (!events.length) {
+            await this.waitForEvents();
+            return this.reserve(amount);
+        }
+        this.updateMetricsGauges();
+        setTimeout(() => {
+            this.reOpen(events.map((event) => event.eventId), deliveryId);
+        }, this.options.achknowledgeTimeoutMs);
+        return events;
+    }
+    onFinalyFailed(handler) {
+        this.finallyFailedHandler = handler;
+    }
+    async acknowledge(eventIds) {
+        if (!this.running) {
+            return;
+        }
+        const lastEventInBuffer = this.buffer[this.buffer.length - 1];
+        this.buffer = this.buffer.filter((event) => {
+            if (eventIds.includes(event.event.eventId)) {
+                this.incMetricsCounter("acknowledged", event.event.eventType, 1);
+                return false;
+            }
+            return true;
+        });
+        if (this.buffer.length <= this.options.bufferSize - this.options.bufferThreshold) {
+            this.waiterBufferThreshold?.();
+        }
+        await this.updateState(this.buffer.length ? undefined : lastEventInBuffer?.event.eventId);
+        this.updateMetricsGauges();
+        if (!this.buffer.length) {
+            this.waiterBufferEmpty?.();
+        }
+    }
+    async fail(eventIds) {
+        if (!this.running || !eventIds.length) {
+            return;
+        }
+        const lastEventInBuffer = this.buffer[this.buffer.length - 1];
+        const failedEvents = [];
+        this.buffer = this.buffer.filter((event) => {
+            if (eventIds.includes(event.event.eventId)) {
+                this.incMetricsCounter("failed", event.event.eventType, 1);
+                failedEvents.push(event.event);
+                return false;
+            }
+            return true;
+        });
+        this.logger?.info(`Failed ${failedEvents.length} events`);
+        void this.options.processor?.failedHandler?.(failedEvents);
+        if (this.buffer.length <= this.options.bufferSize - this.options.bufferThreshold) {
+            this.waiterBufferThreshold?.();
+        }
+        await this.updateState(this.buffer.length ? undefined : lastEventInBuffer?.event.eventId);
+        if (!this.buffer.length) {
+            this.waiterBufferEmpty?.();
+        }
+    }
+    async reOpen(eventIds, deliveryId) {
+        let lastEvent;
+        const failedEvents = [];
+        const reopenedEvents = [];
+        this.buffer = this.buffer.filter((event) => {
+            if (event.deliveryId !== deliveryId || !eventIds.includes(event.event.eventId)) {
+                return true;
+            }
+            if (this.options.maxRedeliveryCount > -1 && event.deliveryCount > this.options.maxRedeliveryCount) {
+                this.incMetricsCounter("failed", event.event.eventType, 1);
+                failedEvents.push(event.event);
+                lastEvent = event.event;
+                return false;
+            }
+            event.status = "open";
+            event.deliveryId = undefined;
+            reopenedEvents.push(event.event);
+            return true;
+        });
+        this.updateMetricsGauges();
+        if (reopenedEvents.length) {
+            this.logger?.info(`Reopened ${reopenedEvents.length} events`);
+            await this.waiterEvents?.();
+        }
+        if (!failedEvents.length) {
+            return;
+        }
+        this.logger?.info(`Failed ${failedEvents.length} events`);
+        void this.options.processor?.failedHandler?.(failedEvents);
+        void this.finallyFailedHandler?.(failedEvents);
+        if (this.buffer.length <= this.options.bufferSize - this.options.bufferThreshold) {
+            this.waiterBufferThreshold?.();
+        }
+        await this.updateState(this.buffer.length ? undefined : lastEvent?.eventId);
+        if (!this.buffer.length) {
+            this.waiterBufferEmpty?.();
+        }
+    }
+    // #endregion
+    // #region Pusher
+    async processLoop() {
+        while (this.running) {
+            try {
+                const events = await this.reserve(this.options.processor?.concurrency ?? 1);
+                await this.options.processor?.handler(events);
+                await this.acknowledge(events.map((event) => event.eventId));
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : "Unknown error";
+                this.logger?.error(`Failed to process events: ${errorMessage}`);
+            }
+        }
+    }
+    // #endregion
+    // #region Metrics
+    updateMetricsGauges() {
+        const stats = new Map();
+        for (const eventType of this.dataSource.eventTypes) {
+            stats.set(eventType, {
+                eventCount: 0,
+                eventReservedCount: 0,
+                eventSizeBytes: 0,
+            });
+        }
+        for (const item of this.buffer) {
+            const stat = stats.get(item.event.eventType);
+            if (!stat) {
+                continue;
+            }
+            stat.eventCount++;
+            if (item.status === "reserved") {
+                stat.eventReservedCount++;
+            }
+            stat.eventSizeBytes += JSON.stringify(item.event.payload).length;
+        }
+        for (const [eventType, stat] of stats) {
+            metrics.bufferEventCountGauge.set({
+                tenant: this.dataSource.tenant,
+                data_core: this.dataSource.dataCore,
+                flow_type: this.dataSource.flowType,
+                event_type: eventType,
+            }, stat.eventCount);
+            metrics.bufferReservedEventCountGauge.set({
+                tenant: this.dataSource.tenant,
+                data_core: this.dataSource.dataCore,
+                flow_type: this.dataSource.flowType,
+                event_type: eventType,
+            }, stat.eventReservedCount);
+            metrics.bufferSizeBytesGauge.set({
+                tenant: this.dataSource.tenant,
+                data_core: this.dataSource.dataCore,
+                flow_type: this.dataSource.flowType,
+                event_type: eventType,
+            }, stat.eventSizeBytes);
+        }
+    }
+    incMetricsCounter(name, eventType, value) {
+        switch (name) {
+            case "acknowledged":
+                metrics.eventsAcknowledgedCounter.inc({
+                    tenant: this.dataSource.tenant,
+                    data_core: this.dataSource.dataCore,
+                    flow_type: this.dataSource.flowType,
+                    event_type: eventType,
+                }, value);
+                break;
+            case "failed":
+                metrics.eventsFailedCounter.inc({
+                    tenant: this.dataSource.tenant,
+                    data_core: this.dataSource.dataCore,
+                    flow_type: this.dataSource.flowType,
+                    event_type: eventType,
+                }, value);
+                break;
+            case "pulled":
+                metrics.eventsPulledSizeBytesCounter.inc({
+                    tenant: this.dataSource.tenant,
+                    data_core: this.dataSource.dataCore,
+                    flow_type: this.dataSource.flowType,
+                    event_type: eventType,
+                }, value);
+                break;
+        }
+    }
+    async waitForEvents() {
+        const promise = new Promise((resolve) => {
+            this.waiterEvents = resolve;
+        });
+        await promise;
+    }
+    async waitForBufferThreshold() {
+        const promise = new Promise((resolve) => {
+            this.waiterBufferThreshold = resolve;
+        });
+        await promise;
+    }
+    async waitForBufferEmpty() {
+        if (!this.buffer.length) {
+            return;
+        }
+        const promise = new Promise((resolve) => {
+            this.waiterBufferEmpty = resolve;
+        });
+        await promise;
+    }
+}

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/data-source.d.ts

@@ -0,0 +1,116 @@
+/**
+ * @module data-source
+ * @description Provides functionality to interact with Flowcore data sources
+ */
+import { type EventListOutput, type FlowcoreClient } from "../../../../sdk/1.71.0/src/mod.js";
+import type { FlowcoreDataPumpAuth, FlowcoreDataPumpDataSource, FlowcoreDataPumpState } from "./types.js";
+/**
+ * Options for configuring a Flowcore data source
+ * @interface FlowcoreDataSourceOptions
+ */
+export interface FlowcoreDataSourceOptions {
+    /** Authentication information for Flowcore */
+    auth: FlowcoreDataPumpAuth;
+    /** Data source configuration */
+    dataSource: FlowcoreDataPumpDataSource;
+    /** Optional base URL override for the Flowcore API */
+    baseUrlOverride?: string;
+    /** When true, disables name-to-ID translation for tenant, dataCore, flowType, and eventTypes */
+    noTranslation?: boolean;
+    /** When true, executes commands in direct mode */
+    directMode?: boolean;
+}
+/**
+ * Provides methods to interact with a Flowcore data source
+ * @class FlowcoreDataSource
+ */
+export declare class FlowcoreDataSource {
+    protected readonly options: FlowcoreDataSourceOptions;
+    /** Flowcore client instance */
+    protected flowcoreClient: FlowcoreClient;
+    /** Cached tenant ID */
+    protected tenantId?: string;
+    /** Cached data core ID */
+    protected dataCoreId?: string;
+    /** Cached flow type ID */
+    protected flowTypeId?: string;
+    /** Cached event type IDs */
+    protected eventTypeIds?: string[];
+    /** Cached time buckets */
+    protected timeBuckets?: string[];
+    /**
+     * Creates a new FlowcoreDataSource instance
+     * @param options - Configuration options for the data source
+     */
+    constructor(options: FlowcoreDataSourceOptions);
+    /**
+     * Gets the tenant name from the data source configuration
+     * @returns Tenant name
+     */
+    get tenant(): string;
+    /**
+     * Gets the data core name from the data source configuration
+     * @returns Data core name
+     */
+    get dataCore(): string;
+    /**
+     * Gets the flow type name from the data source configuration
+     * @returns Flow type name
+     */
+    get flowType(): string;
+    /**
+     * Gets the event type names from the data source configuration
+     * @returns Array of event type names
+     */
+    get eventTypes(): string[];
+    /**
+     * Gets the tenant ID, translating from name if necessary
+     * @returns Promise that resolves to the tenant ID
+     */
+    getTenantId(): Promise<string>;
+    /**
+     * Gets the data core ID, translating from name if necessary
+     * @returns Promise that resolves to the data core ID
+     */
+    getDataCoreId(): Promise<string>;
+    /**
+     * Gets the flow type ID, translating from name if necessary
+     * @returns Promise that resolves to the flow type ID
+     */
+    getFlowTypeId(): Promise<string>;
+    /**
+     * Gets the event type IDs, translating from names if necessary
+     * @returns Promise that resolves to an array of event type IDs
+     * @throws Error if an event type is not found
+     */
+    getEventTypeIds(): Promise<string[]>;
+    /**
+     * Gets all time buckets for the configured event types
+     * @param force - When true, forces a refresh of cached time buckets
+     * @returns Promise that resolves to an array of time bucket strings
+     */
+    getTimeBuckets(force?: boolean): Promise<string[]>;
+    /**
+     * Gets the next time bucket after the specified time bucket
+     * @param timeBucket - The reference time bucket
+     * @returns Promise that resolves to the next time bucket, or null if none exists
+     */
+    getNextTimeBucket(timeBucket: string): Promise<string | null>;
+    /**
+     * Gets the closest time bucket to the specified time bucket
+     * @param timeBucket - The reference time bucket
+     * @param getBefore - When true, gets the closest time bucket before the reference
+     * @returns Promise that resolves to the closest time bucket, or null if none exists
+     * @throws Error if the time bucket format is invalid
+     */
+    getClosestTimeBucket(timeBucket: string, getBefore?: boolean): Promise<string | null>;
+    /**
+     * Gets events from the data source starting from a specific state
+     * @param from - The state to start from (includes timeBucket and eventId)
+     * @param amount - Maximum number of events to retrieve
+     * @param toEventId - Optional ID to stop at when retrieving events
+     * @returns Promise that resolves to an array of Flowcore events
+     */
+    getEvents(from: FlowcoreDataPumpState, amount: number, toEventId?: string, cursor?: string, includeSensitiveData?: boolean): Promise<EventListOutput>;
+}
+//# sourceMappingURL=data-source.d.ts.map

package/esm/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/data-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-source.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@flowcore/data-pump/0.16.5/src/data-pump/data-source.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAGL,KAAK,eAAe,EAEpB,KAAK,cAAc,EAIpB,MAAM,mCAAmC,CAAA;AAE1C,OAAO,KAAK,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAEzG;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC,8CAA8C;IAC9C,IAAI,EAAE,oBAAoB,CAAA;IAC1B,gCAAgC;IAChC,UAAU,EAAE,0BAA0B,CAAA;IACtC,sDAAsD;IACtD,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,gGAAgG;IAChG,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,kDAAkD;IAClD,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED;;;GAGG;AACH,qBAAa,kBAAkB;IAkBjB,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,yBAAyB;IAjBjE,+BAA+B;IAC/B,SAAS,CAAC,cAAc,EAAE,cAAc,CAAA;IACxC,uBAAuB;IACvB,SAAS,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC3B,0BAA0B;IAC1B,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC7B,0BAA0B;IAC1B,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC7B,4BAA4B;IAC5B,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;IACjC,0BAA0B;IAC1B,SAAS,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IAEhC;;;OAGG;gBAC4B,OAAO,EAAE,yBAAyB;IAIjE;;;OAGG;IACH,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED;;;OAGG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;;OAGG;IACH,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED;;;OAGG;IACH,IAAW,UAAU,IAAI,MAAM,EAAE,CAEhC;IAED;;;OAGG;IACU,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IAkB3C;;;OAGG;IACU,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;IAkB7C;;;OAGG;IACU,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC;IAkB7C;;;;OAIG;IACU,eAAe,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAyBjD;;;;OAIG;IACU,cAAc,CAAC,KAAK,UAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAwB7D;;;;OAIG;IACU,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAa1E;;;;;;OAMG;IACU,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,UAAQ,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAiBhG;;;;;;OAMG;IACU,SAAS,CACpB,IAAI,EAAE,qBAAqB,EAC3B,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,MAAM,CAAC,EAAE,MAAM,EACf,oBAAoB,UAAQ,GAC3B,OAAO,CAAC,eAAe,CAAC;CAiB5B"}