ctrl-fx 0.1.0 → 0.1.1

package/dist/internal/dbmgr.js

@@ -1,200 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,337 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}