prostgles-client 4.0.357 → 4.0.359

package/dist/SyncedTable/createSync.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSync = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const WAL_1 = require("prostgles-types/dist/WAL");
+const createSyncDataStore_1 = require("./createSyncDataStore");
+const createSyncStateUtils_1 = require("./createSyncStateUtils");
+const createSyncSubscriptionManager_1 = require("./createSyncSubscriptionManager");
+const SyncedTable_1 = require("./SyncedTable");
+const createSync = async (socket, options) => {
+    var _a;
+    const stateUtils = (0, createSyncStateUtils_1.createSyncStateUtils)(socket, options);
+    const { state, onDebug, id_fields, synced_field, throttle, batch_size, columns, _syncInfo, _sync, filter, } = stateUtils;
+    const store = (0, createSyncDataStore_1.createSyncDataStore)({ ..._syncInfo, columns, filter });
+    const onError = (_a = options.onError) !== null && _a !== void 0 ? _a : function (err) {
+        console.error("Sync internal error: ", err);
+    };
+    const onSyncRequest = (syncBatchParams) => {
+        let clientSyncInfo = { c_lr: undefined, c_fr: undefined, c_count: 0 };
+        const batch = store.getBatch(syncBatchParams);
+        if (batch.length) {
+            clientSyncInfo = {
+                c_fr: store.getRowSyncObj(batch[0]),
+                c_lr: store.getRowSyncObj(batch[batch.length - 1]),
+                c_count: batch.length,
+            };
+        }
+        onDebug({ command: "onUpdates", data: { syncBatchParams, batch, clientSyncInfo } });
+        return clientSyncInfo;
+    };
+    const onPullRequest = async (syncBatchParams) => {
+        // if(this.getDeleted().length){
+        //     await this.syncDeleted();
+        // }
+        const data = store.getBatch(syncBatchParams);
+        await onDebug({ command: "onPullRequest", data: { syncBatchParams, data } });
+        return { data };
+    };
+    const onUpdates = async (onUpdatesParams) => {
+        await onDebug({ command: "onUpdates", data: { onUpdatesParams } });
+        if ("err" in onUpdatesParams && onUpdatesParams.err) {
+            onError(onUpdatesParams.err);
+        }
+        else if ("isSynced" in onUpdatesParams && onUpdatesParams.isSynced && !state.isSynced) {
+            state.isSynced = onUpdatesParams.isSynced;
+            const items = store.getItems().map((d) => ({ ...d }));
+            store.setItems([]);
+            const updateItems = items.map((d) => ({
+                idObj: store.getIdObj(d),
+                delta: { ...d },
+            }));
+            await upsert(updateItems, true);
+        }
+        else if ("data" in onUpdatesParams) {
+            /* Delta left empty so we can prepare it here */
+            const updateItems = onUpdatesParams.data.map((d) => {
+                return {
+                    idObj: store.getIdObj(d),
+                    delta: d,
+                };
+            });
+            await upsert(updateItems, true);
+        }
+        else {
+            console.error("Unexpected onUpdates");
+        }
+        return true;
+    };
+    const opts = {
+        id_fields,
+        synced_field,
+        throttle,
+    };
+    const dbSync = await _sync({ onSyncRequest, onPullRequest, onUpdates });
+    /**
+     * Some syncs can be read only. Any changes are local
+     */
+    const wal = new WAL_1.WAL({
+        ...opts,
+        batch_size,
+        onSendStart: () => {
+            if (isWindowDefined) {
+                window.onbeforeunload = function confirmExit() {
+                    return "Data may be lost. Are you sure?";
+                };
+            }
+        },
+        onSend: async (data, walData) => {
+            const _data = walData.map((d) => d.current);
+            if (!_data.length)
+                return [];
+            return dbSync.syncData(data);
+        },
+        onSendEnd: () => {
+            if (isWindowDefined)
+                window.onbeforeunload = null;
+        },
+    });
+    /**
+     * Upserts data locally -> notify subs -> sends to server if required
+     * synced_field is populated if data is not from server
+     * @param items <{ idObj: object, delta: object }[]> Data items that changed
+     * @param from_server : <boolean> If false then updates will be sent to server
+     */
+    const upsert = async (items, from_server = false) => {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if ((!items || !items.length) && !from_server)
+            throw "No data provided for upsert";
+        /* If data has been deleted then wait for it to sync with server before continuing */
+        // if(from_server && this.getDeleted().length){
+        //     await this.syncDeleted();
+        // }
+        const results = [];
+        let status;
+        const walItems = [];
+        await Promise.all(items.map(async (item, i) => {
+            var _a;
+            // let d = { ...item.idObj, ...item.delta };
+            const idObj = { ...item.idObj };
+            let delta = { ...item.delta };
+            /* Convert undefined to null because:
+              1) JSON.stringify drops these keys
+              2) Postgres does not have undefined
+          */
+            Object.keys(delta).map((k) => {
+                if (delta[k] === undefined)
+                    delta[k] = null;
+            });
+            if (!from_server) {
+                store.checkItemCols({ ...item.delta, ...item.idObj });
+            }
+            const oldItem = store.getItem(idObj);
+            /* Calc delta if missing or if from server */
+            if ((from_server || (0, prostgles_types_1.isEmpty)(delta)) && !(0, prostgles_types_1.isEmpty)(oldItem)) {
+                delta = store.getDelta(oldItem || {}, delta);
+            }
+            /* Add synced if local update */
+            /** Will need to check client clock shift */
+            if (!from_server) {
+                delta[synced_field] = Date.now();
+            }
+            let newItem = { ...oldItem, ...delta, ...idObj };
+            if (oldItem && !from_server) {
+                /**
+                 * Merge deep
+                 */
+                if ((_a = item.opts) === null || _a === void 0 ? void 0 : _a.deepMerge) {
+                    newItem = (0, SyncedTable_1.mergeDeep)({ ...oldItem, ...idObj }, { ...delta });
+                }
+            }
+            /* Update existing -> Expecting delta */
+            if (oldItem) {
+                status = oldItem[synced_field] < newItem[synced_field] ? "updated" : "unchanged";
+                /* Insert new item */
+            }
+            else {
+                status = "inserted";
+            }
+            store.setItem(newItem);
+            // if(!status) throw "changeInfo status missing"
+            const changeInfo = { idObj, delta, oldItem, newItem, status, from_server };
+            /* IF Local updates then Keep any existing oldItem to revert to the earliest working item */
+            if (!from_server) {
+                walItems.push({
+                    initial: oldItem,
+                    current: { ...newItem },
+                });
+            }
+            if (!(0, prostgles_types_1.isEmpty)(changeInfo.delta)) {
+                results.push(changeInfo);
+            }
+            /* TODO: Deletes from server */
+            // if(allow_deletes){
+            //     items = this.getItems();
+            // }
+            return true;
+        })).catch((err) => {
+            console.error("SyncedTable failed upsert: ", err);
+        });
+        subscriptionManager.notifyWal.addData(results.map((d) => ({ initial: d.oldItem, current: d.newItem })));
+        /* Push to server */
+        if (!from_server && walItems.length) {
+            wal.addData(walItems);
+        }
+    };
+    const subscriptionManager = (0, createSyncSubscriptionManager_1.createSyncSubscriptionManager)({ id_fields, synced_field }, store, stateUtils, upsert);
+    return subscriptionManager;
+};
+exports.createSync = createSync;
+const isWindowDefined = typeof window !== "undefined";

package/dist/SyncedTable/createSyncDataStore.d.ts

@@ -0,0 +1,19 @@
+import type { SyncInfo } from "lib/prostgles";
+import { type AnyObject, type SyncBatchParams } from "prostgles-types";
+import { type SyncedTableOptions } from "./SyncedTable";
+export declare const createSyncDataStore: ({ id_fields, synced_field, filter, columns, }: Pick<SyncInfo, "id_fields" | "synced_field"> & Pick<SyncedTableOptions, "filter" | "columns">) => {
+    getItems: <T extends AnyObject = AnyObject>() => T[];
+    getBatch: ({ from_synced, to_synced, offset, limit }?: SyncBatchParams) => {
+        [x: string]: any;
+    }[];
+    getIdObj: (d: AnyObject) => AnyObject;
+    getRowSyncObj: (d: AnyObject) => AnyObject;
+    getDelta: (o: AnyObject, n: AnyObject) => AnyObject;
+    setItems: (_items: AnyObject[]) => void;
+    checkItemCols: (item: AnyObject) => void;
+    setItem: (_item: AnyObject, isFullData?: boolean, deleteItem?: boolean) => void;
+    getItem: <T = AnyObject>(idObj: Partial<T>) => T | undefined;
+    matchesIdObj: (a: AnyObject | undefined, b: AnyObject | undefined) => boolean;
+    matchesFilter: (item: AnyObject | undefined) => boolean;
+};
+//# sourceMappingURL=createSyncDataStore.d.ts.map

package/dist/SyncedTable/createSyncDataStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSyncDataStore.d.ts","sourceRoot":"","sources":["../../lib/SyncedTable/createSyncDataStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAML,KAAK,SAAS,EACd,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAc,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAEpE,eAAO,MAAM,mBAAmB,GAAI,+CAKjC,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,cAAc,CAAC,GAC7C,IAAI,CAAC,kBAAkB,EAAE,QAAQ,GAAG,SAAS,CAAC;eA2B5B,CAAC,SAAS,SAAS,mBAAiB,CAAC,EAAE;2DAyBZ,eAAe;;;kBA3CvC,SAAS;uBAOJ,SAAS;kBA0Fd,SAAS,KAAK,SAAS,KAAG,SAAS;uBA3B9B,SAAS,EAAE,KAAG,IAAI;0BAkBf,SAAS;qBA7Bd,SAAS;cAoBhB,CAAC,qBAAqB,OAAO,CAAC,CAAC,CAAC,KAAG,CAAC,GAAG,SAAS;sBA0CxC,SAAS,GAAG,SAAS,KAAK,SAAS,GAAG,SAAS;0BAN3C,SAAS,GAAG,SAAS;CAuBnD,CAAC"}

package/dist/SyncedTable/createSyncDataStore.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSyncDataStore = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const SyncedTable_1 = require("./SyncedTable");
+const createSyncDataStore = ({ id_fields, synced_field, filter, columns, }) => {
+    const itemsMap = new Map();
+    const idFieldsSorted = id_fields.sort();
+    const syncFieldSorted = [synced_field, ...id_fields].sort();
+    const getIdStr = (d) => {
+        return idFieldsSorted.map((key) => `${d[key] || ""}`).join(".");
+    };
+    const getIdObj = (d) => {
+        const res = {};
+        idFieldsSorted.map((key) => {
+            res[key] = d[key];
+        });
+        return res;
+    };
+    const getRowSyncObj = (d) => {
+        const res = {};
+        syncFieldSorted.map((key) => {
+            res[key] = d[key];
+        });
+        return res;
+    };
+    /**
+     * Returns the current data ordered by synced_field ASC and matching the main filter;
+     */
+    const getItems = () => {
+        let items = [];
+        items = Array.from(itemsMap.values()).map((d) => ({ ...d }));
+        const syncFields = [synced_field, ...id_fields.sort()];
+        items = items
+            .filter((d) => {
+            return !filter || !(0, prostgles_types_1.getKeys)(filter).find((key) => d[key] !== filter[key]);
+        })
+            .sort((a, b) => syncFields
+            .map((key) => (a[key] < b[key] ? -1
+            : a[key] > b[key] ? 1
+                : 0))
+            .find((v) => v));
+        return (0, SyncedTable_1.quickClone)(items);
+    };
+    const getBatch = ({ from_synced, to_synced, offset, limit } = { offset: 0, limit: undefined }) => {
+        const items = getItems();
+        let res = items
+            .map((c) => ({ ...c }))
+            .filter((c) => (!Number.isFinite(from_synced) || +c[synced_field] >= +from_synced) &&
+            (!Number.isFinite(to_synced) || +c[synced_field] <= +to_synced));
+        if (offset || limit) {
+            res = res.splice(offset !== null && offset !== void 0 ? offset : 0, limit || res.length);
+        }
+        return res;
+    };
+    const setItem = (_item, isFullData = false, deleteItem = false) => {
+        var _a;
+        const item = (0, SyncedTable_1.quickClone)(_item);
+        const id = getIdStr(item);
+        if (deleteItem) {
+            itemsMap.delete(id);
+        }
+        else {
+            const existing = (_a = itemsMap.get(id)) !== null && _a !== void 0 ? _a : {};
+            itemsMap.set(id, isFullData ? { ...item } : { ...existing, ...item });
+        }
+    };
+    const setItems = (_items) => {
+        const items = (0, SyncedTable_1.quickClone)(_items);
+        itemsMap.clear();
+        items.forEach((item) => {
+            const id = getIdStr(item);
+            itemsMap.set(id, { ...item });
+        });
+    };
+    const getItem = (idObj) => {
+        const d = itemsMap.get(getIdStr(idObj));
+        return (0, SyncedTable_1.quickClone)(d);
+    };
+    /**
+     * Ensures that all object keys match valid column names
+     */
+    const checkItemCols = (item) => {
+        if (columns.length) {
+            const badCols = Object.keys({ ...item }).filter((k) => !columns.find((c) => c.name === k));
+            if (badCols.length) {
+                throw `Unexpected columns in sync item update: ` + badCols.join(", ");
+            }
+        }
+    };
+    const getDelta = (o, n) => {
+        if ((0, prostgles_types_1.isEmpty)(o))
+            return { ...n };
+        return Object.fromEntries(Object.entries({ ...n })
+            .filter(([k]) => !id_fields.includes(k))
+            .map(([k, v]) => {
+            if (!(0, prostgles_types_1.isEqual)(v, o[k])) {
+                const vClone = (0, prostgles_types_1.isObject)(v) ? { ...v }
+                    : Array.isArray(v) ? v.slice(0)
+                        : v;
+                return [k, vClone];
+            }
+        })
+            .filter(prostgles_types_1.isDefined));
+    };
+    const matchesFilter = (item) => {
+        return Boolean(item &&
+            (!filter || (0, prostgles_types_1.isEmpty)(filter) || !Object.keys(filter).find((k) => filter[k] !== item[k])));
+    };
+    const matchesIdObj = (a, b) => {
+        return Boolean(a && b && !id_fields.sort().find((k) => a[k] !== b[k]));
+    };
+    return {
+        getItems,
+        getBatch,
+        getIdObj,
+        getRowSyncObj,
+        getDelta,
+        setItems,
+        checkItemCols,
+        setItem,
+        getItem,
+        matchesIdObj,
+        matchesFilter,
+    };
+};
+exports.createSyncDataStore = createSyncDataStore;

package/dist/SyncedTable/createSyncStateUtils.d.ts

@@ -0,0 +1,25 @@
+import { type SyncDebugEvent, type SyncInfo } from "lib/prostgles";
+import { type ClientSyncHandles } from "prostgles-types";
+import type { Socket } from "socket.io-client";
+import type { SyncedTableOptions } from "./SyncedTable";
+export declare const createSyncStateUtils: (socket: Socket, options: Omit<SyncedTableOptions, "onReady">) => {
+    state: {
+        isSynced: boolean;
+    };
+    onDebug: (evt: Omit<SyncDebugEvent, "type" | "tableName" | "channelName" | "options">) => void | Promise<void> | undefined;
+    id_fields: string[];
+    synced_field: string;
+    throttle: number;
+    batch_size: number;
+    columns: import("prostgles-types").ValidatedColumnInfo[];
+    _syncInfo: import("prostgles-types").SyncTableInfo;
+    _sync: (handles: ClientSyncHandles) => Promise<{
+        sync_info: SyncInfo;
+        unsync: () => Promise<unknown>;
+        syncData: (data?: import("prostgles-types").AnyObject[], deleted?: import("prostgles-types").AnyObject[], cb?: (err?: any) => void) => void;
+    }>;
+    filter: import("prostgles-types").EqualityFilter<import("prostgles-types").AnyObject>;
+    select: import("prostgles-types").FieldFilter;
+    tableHandler: Partial<import("prostgles-types").TableHandler & import("lib/prostgles").TableHandlerClientMethods<import("prostgles-types").AnyObject, void>>;
+};
+//# sourceMappingURL=createSyncStateUtils.d.ts.map

package/dist/SyncedTable/createSyncStateUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSyncStateUtils.d.ts","sourceRoot":"","sources":["../../lib/SyncedTable/createSyncStateUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrF,OAAO,EAGL,KAAK,iBAAiB,EAEvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAe,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAErE,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,MAAM,EACd,SAAS,IAAI,CAAC,kBAAkB,EAAE,SAAS,CAAC;;;;mBAKtB,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW,GAAG,aAAa,GAAG,SAAS,CAAC;;;;;;;qBAyB9D,iBAAiB;;;2HAkIi6B,CAAC;;;;;CADl9B,CAAC"}

package/dist/SyncedTable/createSyncStateUtils.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSyncStateUtils = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const createSyncStateUtils = (socket, options) => {
+    const state = { isSynced: false };
+    const { db, name, select = "*", filter = {}, columns } = options;
+    const channelName = (0, prostgles_types_1.getSyncChannelName)({ filter, select, tableName: name });
+    const onDebug = (evt) => {
+        var _a;
+        return (_a = options.onDebug) === null || _a === void 0 ? void 0 : _a.call(options, {
+            ...evt,
+            type: "sync",
+            tableName: name,
+            channelName,
+            options,
+        });
+    };
+    onDebug({ command: "create", data: { name, filter, select } });
+    const tableHandler = db[name];
+    if (!tableHandler) {
+        throw `${name} table not found in db`;
+    }
+    const { _syncInfo } = tableHandler;
+    if (!_syncInfo) {
+        throw `${name} table does not support sync`;
+    }
+    const { id_fields, synced_field, throttle = 100, batch_size = 50 } = _syncInfo;
+    if (!id_fields.length || !synced_field) {
+        throw "id_fields/synced_field missing";
+    }
+    const _sync = async (handles) => {
+        const sync_info = await new Promise((resolve, reject) => {
+            socket.emit(prostgles_types_1.CHANNEL_PREFIX, {
+                tableName: name,
+                command: "sync",
+                param1: filter,
+                param2: { select },
+            }, (err, syncInfo) => {
+                if (err) {
+                    console.error(err);
+                    reject(err);
+                }
+                else if (syncInfo) {
+                    const { id_fields, synced_field, channelName } = syncInfo;
+                    socket.emit(channelName, { onSyncRequest: handles.onSyncRequest({}) }, (response) => {
+                        console.log(response);
+                    });
+                    resolve({ id_fields, synced_field, channelName });
+                }
+            });
+        });
+        const onCall = function (data, cb) {
+            /*
+                  Client will:
+                  1. Send last_synced     on(onSyncRequest)
+                  2. Send data >= server_synced   on(onPullRequest)
+                  3. Send data on CRUD    emit(data.data)
+                  4. Upsert data.data     on(data.data)
+              */
+            if (!data)
+                return;
+            const { onUpdates, onSyncRequest, onPullRequest } = handles;
+            // syncedTables.get(channelName)?.then((syncedTable) => {
+            //   onDebug?.({
+            //     type: "sync",
+            //     command:
+            //       data.data ? "onUpdates"
+            //       : data.onSyncRequest ? "onSyncRequest"
+            //       : "onPullRequest",
+            //     tableName,
+            //     channelName,
+            //     data,
+            //     options: { n filter, select },
+            //   });
+            // });
+            if (data.data) {
+                Promise.resolve(onUpdates(data))
+                    .then(() => {
+                    cb({ ok: true });
+                })
+                    .catch((err) => {
+                    cb({ err });
+                });
+            }
+            else if (data.onSyncRequest) {
+                Promise.resolve(onSyncRequest(data.onSyncRequest))
+                    .then((res) => cb({ onSyncRequest: res }))
+                    .catch((err) => {
+                    cb({ err });
+                });
+            }
+            else if (data.onPullRequest) {
+                Promise.resolve(onPullRequest(data.onPullRequest))
+                    .then((result) => {
+                    cb(result);
+                })
+                    .catch((err) => {
+                    cb({ err });
+                });
+            }
+            else {
+                console.log("unexpected response");
+            }
+        };
+        socket.on(channelName, onCall);
+        const syncData = function (data, deleted, cb) {
+            socket.emit(channelName, {
+                onSyncRequest: {
+                    ...handles.onSyncRequest({}),
+                    ...{ data },
+                    ...{ deleted },
+                },
+            }, !cb ? null : ((response) => {
+                cb(response);
+            }));
+        };
+        const unsync = () => {
+            return new Promise((resolve, reject) => {
+                socket.emit(channelName + "unsync", {}, (err, res) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(res);
+                });
+                socket.removeListener(channelName, onCall);
+            });
+        };
+        return { sync_info, unsync, syncData };
+    };
+    return {
+        state,
+        onDebug,
+        id_fields,
+        synced_field,
+        throttle,
+        batch_size,
+        columns,
+        _syncInfo,
+        _sync,
+        filter,
+        select,
+        tableHandler,
+    };
+};
+exports.createSyncStateUtils = createSyncStateUtils;

package/dist/SyncedTable/createSyncSubscriptionManager.d.ts

@@ -0,0 +1,11 @@
+import type { AnyObject, SyncConfig } from "prostgles-types";
+import { WAL } from "prostgles-types/dist/WAL";
+import type { createSyncDataStore } from "./createSyncDataStore";
+import type { createSyncStateUtils } from "./createSyncStateUtils";
+import type { ItemUpdate, MultiChangeListener, MultiSyncHandles, SingleChangeListener, SingleSyncHandles } from "./SyncedTable";
+export declare const createSyncSubscriptionManager: ({ id_fields, synced_field }: Omit<SyncConfig, "channelName">, store: ReturnType<typeof createSyncDataStore>, stateUtils: ReturnType<typeof createSyncStateUtils>, upsert: (items: ItemUpdate[], from_server?: boolean) => Promise<void>) => {
+    sync: <T extends AnyObject = AnyObject>(onChange: MultiChangeListener<T>, handlesOnData?: boolean) => MultiSyncHandles<T>;
+    syncOne: <T extends AnyObject = AnyObject, Full extends boolean = false>(idObj: Partial<T>, onChange: SingleChangeListener<T, Full>, handlesOnData?: boolean) => SingleSyncHandles<T, Full>;
+    notifyWal: WAL;
+};
+//# sourceMappingURL=createSyncSubscriptionManager.d.ts.map

package/dist/SyncedTable/createSyncSubscriptionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSyncSubscriptionManager.d.ts","sourceRoot":"","sources":["../../lib/SyncedTable/createSyncSubscriptionManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAiB,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,EAAE,GAAG,EAAE,MAAM,0BAA0B,CAAC;AAC/C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAEV,UAAU,EAEV,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EAIlB,MAAM,eAAe,CAAC;AAEvB,eAAO,MAAM,6BAA6B,GACxC,6BAA6B,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,EAC5D,OAAO,UAAU,CAAC,OAAO,mBAAmB,CAAC,EAC7C,YAAY,UAAU,CAAC,OAAO,oBAAoB,CAAC,EACnD,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,WAAW,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC;WAgKvD,CAAC,SAAS,SAAS,wBACrB,mBAAmB,CAAC,CAAC,CAAC,8BAE/B,gBAAgB,CAAC,CAAC,CAAC;cAsDL,CAAC,SAAS,SAAS,cAAc,IAAI,SAAS,OAAO,iBAC7D,OAAO,CAAC,CAAC,CAAC,YACP,oBAAoB,CAAC,CAAC,EAAE,IAAI,CAAC,8BAEtC,iBAAiB,CAAC,CAAC,EAAE,IAAI,CAAC;;CAuC9B,CAAC"}