ctrl-fx 0.0.1 → 0.1.0

package/dist/internal/dbmgr.js

@@ -0,0 +1,200 @@
+import { dbVersion } from '../db';
+import { constraintError, notFoundError, unexpectedError, } from '../db/errors';
+import { run as runDbEffect } from '../db/effects';
+import { run as runDbSetupEffect } from '../db/setup';
+import { failure, success } from '../utils/result';
+export class DbManager {
+    constructor() {
+        Object.defineProperty(this, "openDatabases", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    open(db, version, setup, callback) {
+        const idbFactory = globalThis.indexedDB;
+        if (!idbFactory) {
+            return callback(failure(unexpectedError({ message: 'IndexedDB not supported' })));
+        }
+        const openRequest = idbFactory.open(db, version);
+        openRequest.onblocked = _event => {
+            window.alert('A database upgrade is blocked. Please close other tabs with this app.');
+        };
+        let upgradeError = undefined;
+        openRequest.onupgradeneeded = versionChangeEvent => {
+            const idbDb = openRequest.result;
+            const tx = openRequest.transaction;
+            if (!tx) {
+                console.warn('Expected idb transaction to be non-null during upgrade');
+                return;
+            }
+            const oldVersion = dbVersion(versionChangeEvent.oldVersion);
+            const effect = setup(oldVersion);
+            try {
+                runDbSetupEffect(effect, setupInterpreter(idbDb, tx), _result => { });
+            }
+            catch (err) {
+                if (err instanceof Error)
+                    upgradeError = err;
+                throw err;
+            }
+        };
+        openRequest.onerror = event => {
+            if (upgradeError instanceof DOMException) {
+                if (upgradeError.name === 'ConstraintError') {
+                    return callback(failure(constraintError(upgradeError)));
+                }
+                if (upgradeError.name === 'NotFoundError') {
+                    return callback(failure(notFoundError(upgradeError)));
+                }
+            }
+            return callback(failure(unexpectedError({
+                message: extractMessage(event),
+                cause: upgradeError,
+            })));
+        };
+        openRequest.onsuccess = _event => {
+            this.openDatabases.set(db, openRequest.result);
+            callback(success(undefined));
+        };
+    }
+    runTransaction(db, objectStores, mode, effect, callback) {
+        const idbDb = this.openDatabases.get(db);
+        if (!idbDb) {
+            return callback(failure(unexpectedError({ message: `Database '${db}' is not open` })));
+        }
+        const tx = idbDb.transaction([...objectStores], mode);
+        let txError = null;
+        tx.onerror = _event => {
+            txError = tx.error;
+        };
+        tx.onabort = _event => {
+            if (txError !== null) {
+                if (txError.name === 'ConstraintError') {
+                    return callback(failure(constraintError(txError)));
+                }
+                if (txError.name === 'NotFoundError') {
+                    return callback(failure(notFoundError(txError)));
+                }
+                return callback(failure(unexpectedError({ cause: txError })));
+            }
+            return callback(failure(unexpectedError({ message: 'Transaction aborted' })));
+        };
+        tx.oncomplete = _event => {
+            callback(success(undefined));
+        };
+        runDbEffect(effect, dbInterpreter(tx), _result => { });
+    }
+}
+function setupInterpreter(db, tx) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (op, onComplete) => {
+        switch (op._type) {
+            case 'CreateObjectStore': {
+                db.createObjectStore(op.objectStore, objectStoreKeyOptions(op.keyPath));
+                onComplete(undefined);
+                return;
+            }
+            case 'CreateIndex': {
+                const store = tx.objectStore(op.objectStore);
+                store.createIndex(op.index, indexKeyPathValue(op.keyPath), {
+                    unique: op.unique,
+                });
+                onComplete(undefined);
+                return;
+            }
+            case 'DeleteObjectStore': {
+                db.deleteObjectStore(op.objectStore);
+                onComplete(undefined);
+                return;
+            }
+            case 'DeleteIndex': {
+                const store = tx.objectStore(op.objectStore);
+                store.deleteIndex(op.index);
+                onComplete(undefined);
+                return;
+            }
+            case 'GetObjectStoreNames': {
+                onComplete(Array.from(db.objectStoreNames));
+                return;
+            }
+            case 'GetIndexNames': {
+                const store = tx.objectStore(op.objectStore);
+                onComplete(Array.from(store.indexNames));
+                return;
+            }
+            case 'RunDbEffect': {
+                runDbEffect(op.effect, dbInterpreter(tx), _result => onComplete(undefined));
+                return;
+            }
+        }
+    };
+}
+function dbInterpreter(tx) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (op, onComplete) => {
+        switch (op._type) {
+            case 'Add': {
+                const req = tx.objectStore(op.objectStore).add(op.value);
+                req.onsuccess = () => onComplete(undefined);
+                return;
+            }
+            case 'Put': {
+                const req = tx.objectStore(op.objectStore).put(op.value);
+                req.onsuccess = () => onComplete(undefined);
+                return;
+            }
+            case 'Get': {
+                const req = tx.objectStore(op.objectStore).get(op.key);
+                req.onsuccess = () => onComplete(req.result ?? undefined);
+                return;
+            }
+            case 'GetAll': {
+                const req = tx.objectStore(op.objectStore).getAll();
+                req.onsuccess = () => onComplete(req.result);
+                return;
+            }
+            case 'Delete': {
+                const req = tx.objectStore(op.objectStore).delete(op.key);
+                req.onsuccess = () => onComplete(undefined);
+                return;
+            }
+            case 'Count': {
+                const req = tx.objectStore(op.objectStore).count();
+                req.onsuccess = () => onComplete(req.result);
+                return;
+            }
+        }
+    };
+}
+function objectStoreKeyOptions(keyPath) {
+    switch (keyPath._type) {
+        case 'AutoIncrement':
+            return { keyPath: keyPath.value, autoIncrement: true };
+        case 'Manual':
+            return { keyPath: keyPath.value, autoIncrement: false };
+        case 'Multi':
+            return {
+                keyPath: [keyPath.first, keyPath.second, ...keyPath.rest],
+                autoIncrement: false,
+            };
+    }
+}
+function indexKeyPathValue(keyPath) {
+    switch (keyPath._type) {
+        case 'SingleIndex':
+            return keyPath.value;
+        case 'MultiIndex':
+            return [keyPath.first, keyPath.second, ...keyPath.rest];
+    }
+}
+function extractMessage(event) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const m = event.message;
+    if (typeof m === 'string')
+        return m;
+    if (m != null)
+        return `${m}`;
+    return undefined;
+}

package/dist/internal/dominterpreter.d.ts

@@ -0,0 +1,5 @@
+import { type Effect } from '../effects';
+import type { Callbacks } from './interpreter';
+import { TaskRegistry } from './taskreg';
+export declare function domInterpreter<State, Event, A>(effect: Effect<State, Event, A>, callbacks: Callbacks<State, Event, A>, taskRegistry: TaskRegistry): void;
+//# sourceMappingURL=dominterpreter.d.ts.map

package/dist/internal/dominterpreter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dominterpreter.d.ts","sourceRoot":"","sources":["../../src/internal/dominterpreter.ts"],"names":[],"mappings":"AAEA,OAAO,EAAU,KAAK,MAAM,EAAe,MAAM,YAAY,CAAA;AAK7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAI9C,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAIxC,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAC5C,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,EAC/B,SAAS,EAAE,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,EACrC,YAAY,EAAE,YAAY,GACzB,IAAI,CAobN"}

package/dist/internal/dominterpreter.js

@@ -0,0 +1,337 @@
+import { generateUuid } from '.';
+import { permission } from '..';
+import { taskId } from '../effects';
+import { formatLocation, parseInternalLocation } from '../net/location';
+import { scrollElementError } from '../scroll';
+import { failure, success } from '../utils/result';
+import { exhaustivenessCheck } from '../utils';
+import { readClipboard, writeClipboard } from './clipboard';
+import { DbManager } from './dbmgr';
+import { makeHttpRequest } from './net';
+import { TaskRegistry } from './taskreg';
+const dbManager = new DbManager();
+export function domInterpreter(effect, callbacks, taskRegistry) {
+    switch (effect._type) {
+        case 'Return': {
+            callbacks.onComplete(effect.value);
+            return;
+        }
+        case 'FlatMap': {
+            domInterpreter(effect.effect, {
+                ...callbacks,
+                onComplete(result) {
+                    domInterpreter(effect.next(result), callbacks, taskRegistry);
+                },
+            }, taskRegistry);
+            return;
+        }
+        case 'Suspend': {
+            switch (effect.operation._type) {
+                case 'Alert': {
+                    globalThis.window.alert(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'Confirm': {
+                    callbacks.onComplete(globalThis.window.confirm(effect.operation.input));
+                    return;
+                }
+                case 'Prompt': {
+                    callbacks.onComplete(globalThis.window.prompt(effect.operation.input.message, effect.operation.input.default));
+                    return;
+                }
+                case 'GetNotificationPermission': {
+                    callbacks.onComplete(permission(globalThis.Notification.permission));
+                    return;
+                }
+                case 'RequestNotificationPermission': {
+                    globalThis.Notification.requestPermission().then(perm => {
+                        callbacks.onComplete(permission(perm));
+                    });
+                    return;
+                }
+                case 'GetLocation': {
+                    const loc = globalThis.window.location;
+                    callbacks.onComplete(parseInternalLocation(loc.pathname + loc.search + loc.hash));
+                    return;
+                }
+                case 'Async': {
+                    const { effect: innerEffect, delayInMillis } = effect.operation.input;
+                    setTimeout(() => {
+                        domInterpreter(innerEffect, { ...callbacks, onComplete() { } }, taskRegistry);
+                    }, delayInMillis);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'CancelTask': {
+                    taskRegistry.cancel(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'ClearAppBadge': {
+                    if (globalThis.navigator.clearAppBadge) {
+                        globalThis.navigator.clearAppBadge();
+                    }
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'SetAppBadge': {
+                    if (globalThis.navigator.setAppBadge) {
+                        globalThis.navigator.setAppBadge(effect.operation.input);
+                    }
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'SetDocumentTitle': {
+                    globalThis.document.title = effect.operation.input;
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'FireEvent': {
+                    callbacks.onFireEvent(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'GetState': {
+                    callbacks.onComplete(callbacks.getState());
+                    return;
+                }
+                case 'GetTime': {
+                    callbacks.onComplete(new Date());
+                    return;
+                }
+                case 'GetRandom': {
+                    callbacks.onComplete(Math.random());
+                    return;
+                }
+                case 'MakeHttpRequest': {
+                    makeHttpRequest(effect.operation.input, result => callbacks.onComplete(result));
+                    return;
+                }
+                case 'Log': {
+                    console.log(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'Product': {
+                    let resultA = '__ctrl_fx_unset_result';
+                    let resultB = '__ctrl_fx_unset_result';
+                    domInterpreter(effect.operation.input[0], {
+                        ...callbacks,
+                        onComplete(a) {
+                            resultA = a;
+                            if (resultB !== '__ctrl_fx_unset_result') {
+                                callbacks.onComplete([resultA, resultB]);
+                            }
+                        },
+                    }, taskRegistry);
+                    domInterpreter(effect.operation.input[1], {
+                        ...callbacks,
+                        onComplete(b) {
+                            resultB = b;
+                            if (resultA !== '__ctrl_fx_unset_result') {
+                                callbacks.onComplete([resultA, resultB]);
+                            }
+                        },
+                    }, taskRegistry);
+                    return;
+                }
+                case 'ScheduleTask': {
+                    let tskId;
+                    // clear task if its already scheduled
+                    if (effect.operation.input.taskId) {
+                        taskRegistry.cancel(effect.operation.input.taskId);
+                        tskId = effect.operation.input.taskId;
+                    }
+                    // setTimeout (one-shot)
+                    if (effect.operation.input.repeatIntervalInMillis === undefined) {
+                        const timerId = globalThis.setTimeout(() => {
+                            domInterpreter(effect.operation.input.task, { ...callbacks, onComplete() { } }, taskRegistry);
+                        }, effect.operation.input.initialDelayInMillis);
+                        tskId ||= taskId(generateUuid());
+                        taskRegistry.set(tskId, () => clearTimeout(timerId));
+                        // setInterval (delay == interval shortcut)
+                    }
+                    else if (effect.operation.input.initialDelayInMillis ===
+                        effect.operation.input.repeatIntervalInMillis) {
+                        const timerId = globalThis.setInterval(() => {
+                            domInterpreter(effect.operation.input.task, { ...callbacks, onComplete() { } }, taskRegistry);
+                        }, effect.operation.input.repeatIntervalInMillis);
+                        tskId ||= taskId(generateUuid());
+                        taskRegistry.set(tskId, () => clearInterval(timerId));
+                    }
+                    else {
+                        // initial delay differs from repeat interval: setTimeout then setInterval
+                        tskId ||= taskId(generateUuid());
+                        const timerId = globalThis.setTimeout(() => {
+                            domInterpreter(effect.operation.input.task, {
+                                ...callbacks,
+                                onComplete() {
+                                    const newTimerId = globalThis.setInterval(() => {
+                                        domInterpreter(effect.operation.input.task, { ...callbacks, onComplete() { } }, taskRegistry);
+                                    }, effect.operation.input.repeatIntervalInMillis);
+                                    taskRegistry.set(tskId, () => clearInterval(newTimerId));
+                                },
+                            }, taskRegistry);
+                        }, effect.operation.input.initialDelayInMillis);
+                        taskRegistry.set(tskId, () => clearTimeout(timerId));
+                    }
+                    callbacks.onComplete(tskId);
+                    return;
+                }
+                case 'SetTimeout': {
+                    setTimeout(() => {
+                        callbacks.onComplete(undefined);
+                    }, effect.operation.input);
+                    return;
+                }
+                case 'PushState': {
+                    const url = formatLocation(effect.operation.input);
+                    history.pushState(null, '', url);
+                    window.dispatchEvent(new Event('locationchange'));
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'ReplaceState': {
+                    const url = formatLocation(effect.operation.input);
+                    history.replaceState(null, '', url);
+                    window.dispatchEvent(new Event('locationchange'));
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'Go': {
+                    history.go(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'GetStorageItem': {
+                    const store = effect.operation.input.storage === 'local'
+                        ? localStorage
+                        : sessionStorage;
+                    callbacks.onComplete(store.getItem(effect.operation.input.key));
+                    return;
+                }
+                case 'SetStorageItem': {
+                    const store = effect.operation.input.storage === 'local'
+                        ? localStorage
+                        : sessionStorage;
+                    store.setItem(effect.operation.input.key, effect.operation.input.value);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'RemoveStorageItem': {
+                    const store = effect.operation.input.storage === 'local'
+                        ? localStorage
+                        : sessionStorage;
+                    store.removeItem(effect.operation.input.key);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'ClearStorage': {
+                    const store = effect.operation.input.storage === 'local'
+                        ? localStorage
+                        : sessionStorage;
+                    store.clear();
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'OpenDatabase': {
+                    const { db, version, setup } = effect.operation.input;
+                    dbManager.open(db, version, setup, result => {
+                        callbacks.onComplete(result);
+                    });
+                    return;
+                }
+                case 'RunDbTransaction': {
+                    const { db, objectStores, mode, effect: dbEffect, } = effect.operation.input;
+                    dbManager.runTransaction(db, objectStores, mode, dbEffect, result => {
+                        callbacks.onComplete(result);
+                    });
+                    return;
+                }
+                case 'UpdateState': {
+                    callbacks.setState(effect.operation.input(callbacks.getState()));
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'GenerateUuid': {
+                    callbacks.onComplete(generateUuid());
+                    return;
+                }
+                case 'ReadClipboard': {
+                    readClipboard(result => callbacks.onComplete(result));
+                    return;
+                }
+                case 'WriteClipboard': {
+                    writeClipboard(effect.operation.input, result => callbacks.onComplete(result));
+                    return;
+                }
+                case 'Download': {
+                    const { filename, content, contentType } = effect.operation.input;
+                    const blob = new Blob([content], { type: contentType });
+                    const url = URL.createObjectURL(blob);
+                    const a = globalThis.document.createElement('a');
+                    a.href = url;
+                    a.download = filename;
+                    globalThis.document.body.appendChild(a);
+                    a.click();
+                    globalThis.document.body.removeChild(a);
+                    URL.revokeObjectURL(url);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'PostBroadcastMessage': {
+                    const bc = new BroadcastChannel(effect.operation.input.channel);
+                    bc.postMessage(effect.operation.input.message);
+                    bc.close();
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'SubscribeToBroadcastChannel': {
+                    const { channel, handler, taskId: tskIdInput } = effect.operation.input;
+                    const tskId = tskIdInput ?? taskId(generateUuid());
+                    const bc = new BroadcastChannel(channel);
+                    bc.onmessage = (event) => {
+                        domInterpreter(handler(event.data), { ...callbacks, onComplete() { } }, taskRegistry);
+                    };
+                    taskRegistry.set(tskId, () => bc.close());
+                    callbacks.onComplete(tskId);
+                    return;
+                }
+                case 'ScrollWindow': {
+                    globalThis.window.scrollTo(effect.operation.input);
+                    callbacks.onComplete(undefined);
+                    return;
+                }
+                case 'ScrollElement': {
+                    const { selector, options } = effect.operation.input;
+                    const el = globalThis.document.querySelector(selector);
+                    if (el === null) {
+                        callbacks.onComplete(failure(scrollElementError(selector)));
+                    }
+                    else {
+                        el.scrollTo(options);
+                        callbacks.onComplete(success(undefined));
+                    }
+                    return;
+                }
+                case 'CustomEffect': {
+                    const { args, f } = effect.operation.input;
+                    const result = f(args);
+                    if (result instanceof Promise) {
+                        result.then(out => callbacks.onComplete(out));
+                    }
+                    else {
+                        callbacks.onComplete(result);
+                    }
+                    return;
+                }
+                default:
+                    exhaustivenessCheck(effect.operation);
+            }
+            break;
+        }
+        default:
+            exhaustivenessCheck(effect);
+    }
+}

package/dist/internal/eventmgr.d.ts

@@ -0,0 +1,41 @@
+import { type EventListenerResult, type EventOptions } from '../dom/events';
+import type { Effect } from '../effects';
+import type { RealWindow } from './realdom';
+import type { ComponentNode, InternalElementNode, ViewNode } from './vdom';
+type ListenerTotals = {
+    regular: number;
+    capture: number;
+};
+type ListenerCounts<EventType extends string> = Record<EventType, ListenerTotals>;
+export declare function makeListenerCounts<EventTypes extends readonly string[]>(eventTypes: EventTypes): ListenerCounts<(typeof eventTypes)[number]>;
+/** Given current counts of all listeners, adjust them for a specific node given
+ * its old listeners and its new listeners. Return which listener counts have
+ * dropped to zero and which listener counts have gone from zero to a positive
+ * number. Also include a set of all the new event types.
+ */
+export declare function adjustCountsAndGetListenerTypesToRemoveAndAdd<K extends string, L extends {
+    _type: K;
+    options?: EventOptions;
+}>(counts: Record<K, ListenerTotals>, oldListeners: readonly L[], newListeners: readonly L[]): {
+    toRemove: Map<K, {
+        regular: boolean;
+        capture: boolean;
+    }>;
+    toAdd: Map<K, {
+        regular: boolean;
+        capture: boolean;
+    }>;
+    allNewEvents: Map<K, {
+        regular: boolean;
+        capture: boolean;
+    }>;
+};
+export declare class EventManager {
+    private containerDelegate;
+    private elementDelegate;
+    constructor(window: RealWindow, runEffect: (effect: Effect<unknown, unknown, EventListenerResult>, node: InternalElementNode | ComponentNode | ViewNode, onResult: (result: EventListenerResult) => void) => void);
+    setContainerListeners(node: ComponentNode | ViewNode): void;
+    setElementListeners(node: InternalElementNode): void;
+}
+export {};
+//# sourceMappingURL=eventmgr.d.ts.map

package/dist/internal/eventmgr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventmgr.d.ts","sourceRoot":"","sources":["../../src/internal/eventmgr.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,mBAAmB,EACxB,KAAK,YAAY,EAMlB,MAAM,eAAe,CAAA;AACtB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAIxC,OAAO,KAAK,EAMV,UAAU,EACX,MAAM,WAAW,CAAA;AAClB,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAoB1E,KAAK,cAAc,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AAE1D,KAAK,cAAc,CAAC,SAAS,SAAS,MAAM,IAAI,MAAM,CACpD,SAAS,EACT,cAAc,CACf,CAAA;AAED,wBAAgB,kBAAkB,CAAC,UAAU,SAAS,SAAS,MAAM,EAAE,EACrE,UAAU,EAAE,UAAU,GACrB,cAAc,CAAC,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,CAK7C;AA2BD;;;;GAIG;AACH,wBAAgB,6CAA6C,CAC3D,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,YAAY,CAAA;CAAE,EAE9C,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,cAAc,CAAC,EACjC,YAAY,EAAE,SAAS,CAAC,EAAE,EAC1B,YAAY,EAAE,SAAS,CAAC,EAAE,GACzB;IACD,QAAQ,EAAE,GAAG,CAAC,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;IACxD,KAAK,EAAE,GAAG,CAAC,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;IACrD,YAAY,EAAE,GAAG,CAAC,CAAC,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;CAC7D,CA8FA;AA8pBD,qBAAa,YAAY;IACvB,OAAO,CAAC,iBAAiB,CAA+B;IACxD,OAAO,CAAC,eAAe,CAA6B;gBAGlD,MAAM,EAAE,UAAU,EAClB,SAAS,EAAE,CACT,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,mBAAmB,CAAC,EACrD,IAAI,EAAE,mBAAmB,GAAG,aAAa,GAAG,QAAQ,EACpD,QAAQ,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,KAC5C,IAAI;IASX,qBAAqB,CAAC,IAAI,EAAE,aAAa,GAAG,QAAQ,GAAG,IAAI;IAI3D,mBAAmB,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI;CAGrD"}