@aelionsdk/transaction 0.1.0-beta.1

package/dist/history.d.ts

@@ -0,0 +1,45 @@
+import type { AelionProject } from '@aelionsdk/project-schema';
+import { TransactionEngine } from './transaction.js';
+import type { EditOptions, ProjectChangeListener, TransactionCommit } from './types.js';
+export interface TransactionHost {
+    readonly revision: bigint;
+    getSnapshot(): Readonly<AelionProject>;
+    edit(options: EditOptions, callback: Parameters<TransactionEngine['edit']>[1]): TransactionCommit;
+    subscribe(listener: ProjectChangeListener): () => void;
+}
+export interface TransactionHistoryOptions {
+    /** Maximum number of semantic edits retained in each history direction. */
+    readonly maxEntries?: number;
+}
+export interface HistoryState {
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly undoDepth: number;
+    readonly redoDepth: number;
+    readonly undoLabel?: string;
+    readonly redoLabel?: string;
+}
+/**
+ * Bounded undo/redo history for local semantic transactions.
+ *
+ * The manager intentionally detects edits made directly through the wrapped
+ * engine. Applying an inverse across an unknown revision would be unsafe; a
+ * collaboration adapter must instead create a fresh compensating command.
+ */
+export declare class TransactionHistory implements TransactionHost {
+    #private;
+    constructor(engine: TransactionEngine, options?: TransactionHistoryOptions);
+    get revision(): bigint;
+    get state(): HistoryState;
+    getSnapshot(): Readonly<AelionProject>;
+    subscribe(listener: ProjectChangeListener): () => void;
+    edit(options: EditOptions, callback: Parameters<TransactionEngine['edit']>[1]): TransactionCommit;
+    /** Ends a coalescing group so a later edit with the same key starts a new undo entry. */
+    finishGroup(group: string): void;
+    /** Reverts the active group without creating redo history. */
+    cancelGroup(group: string): TransactionCommit | null;
+    undo(): TransactionCommit;
+    redo(): TransactionCommit;
+    clear(): void;
+}
+//# sourceMappingURL=history.d.ts.map

package/dist/history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../src/history.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAEV,WAAW,EACX,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,WAAW,IAAI,QAAQ,CAAC,aAAa,CAAC,CAAC;IACvC,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC;IAClG,SAAS,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,IAAI,CAAC;CACxD;AAED,MAAM,WAAW,yBAAyB;IACxC,2EAA2E;IAC3E,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAuCD;;;;;;GAMG;AACH,qBAAa,kBAAmB,YAAW,eAAe;;gBASrC,MAAM,EAAE,iBAAiB,EAAE,OAAO,GAAE,yBAA8B;IAUrF,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,IAAW,KAAK,IAAI,YAAY,CAW/B;IAEM,WAAW,IAAI,QAAQ,CAAC,aAAa,CAAC;IAItC,SAAS,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,IAAI;IAKtD,IAAI,CACT,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,UAAU,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,GACjD,iBAAiB;IAoCpB,yFAAyF;IAClF,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAYvC,8DAA8D;IACvD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAqBpD,IAAI,IAAI,iBAAiB;IAoBzB,IAAI,IAAI,iBAAiB;IAoBzB,KAAK,IAAI,IAAI;CA0CrB"}

package/dist/history.js

@@ -0,0 +1,210 @@
+import { AelionError } from '@aelionsdk/core';
+import { TransactionEngine } from './transaction.js';
+function historyError(code, message) {
+    return new AelionError([{ code, severity: 'error', message, recoverable: true }]);
+}
+function cloneOperations(operations) {
+    return operations.map(operation => structuredClone(operation));
+}
+function sameField(left, right) {
+    return (left.op === 'setField' &&
+        right.op === 'setField' &&
+        left.collection === right.collection &&
+        left.id === right.id &&
+        left.path.length === right.path.length &&
+        left.path.every((segment, index) => segment === right.path[index]));
+}
+function canReplaceGroupedFields(previous, next) {
+    return (previous.operations.length === next.operations.length &&
+        previous.inverse.length === next.inverse.length &&
+        previous.operations.every((operation, index) => {
+            const nextOperation = next.operations[index];
+            return nextOperation !== undefined && sameField(operation, nextOperation);
+        }));
+}
+/**
+ * Bounded undo/redo history for local semantic transactions.
+ *
+ * The manager intentionally detects edits made directly through the wrapped
+ * engine. Applying an inverse across an unknown revision would be unsafe; a
+ * collaboration adapter must instead create a fresh compensating command.
+ */
+export class TransactionHistory {
+    #engine;
+    #maxEntries;
+    #undo = [];
+    #redo = [];
+    #listeners = new Set();
+    #expectedRevision;
+    #publishing = false;
+    constructor(engine, options = {}) {
+        const maxEntries = options.maxEntries ?? 100;
+        if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) {
+            throw new RangeError('maxEntries must be a positive safe integer');
+        }
+        this.#engine = engine;
+        this.#maxEntries = maxEntries;
+        this.#expectedRevision = engine.revision;
+    }
+    get revision() {
+        return this.#engine.revision;
+    }
+    get state() {
+        const undoLabel = this.#undo.at(-1)?.label;
+        const redoLabel = this.#redo.at(-1)?.label;
+        return {
+            canUndo: this.#undo.length > 0,
+            canRedo: this.#redo.length > 0,
+            undoDepth: this.#undo.length,
+            redoDepth: this.#redo.length,
+            ...(undoLabel === undefined ? {} : { undoLabel }),
+            ...(redoLabel === undefined ? {} : { redoLabel }),
+        };
+    }
+    getSnapshot() {
+        return this.#engine.getSnapshot();
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        return () => this.#listeners.delete(listener);
+    }
+    edit(options, callback) {
+        this.#assertNotPublishing();
+        this.#assertSynchronized();
+        if (options.historyGroup !== undefined && options.historyGroup.length === 0) {
+            throw new TypeError('historyGroup must be a non-empty string');
+        }
+        const commit = this.#engine.edit(options, callback);
+        const entry = {
+            ...(commit.changeSet.label === undefined ? {} : { label: commit.changeSet.label }),
+            ...(options.historyGroup === undefined ? {} : { group: options.historyGroup }),
+            operations: cloneOperations(commit.changeSet.operations),
+            inverse: cloneOperations(commit.inverse),
+        };
+        const previous = this.#undo.at(-1);
+        if (options.historyGroup !== undefined && previous?.group === options.historyGroup) {
+            const replaceFields = canReplaceGroupedFields(previous, entry);
+            this.#undo[this.#undo.length - 1] = {
+                ...((entry.label ?? previous.label) === undefined
+                    ? {}
+                    : { label: entry.label ?? previous.label }),
+                group: options.historyGroup,
+                operations: replaceFields
+                    ? entry.operations
+                    : [...previous.operations, ...entry.operations],
+                inverse: replaceFields ? previous.inverse : [...entry.inverse, ...previous.inverse],
+            };
+        }
+        else {
+            this.#undo.push(entry);
+        }
+        this.#trim(this.#undo);
+        this.#redo.length = 0;
+        this.#expectedRevision = commit.revision;
+        this.#notify(commit);
+        return commit;
+    }
+    /** Ends a coalescing group so a later edit with the same key starts a new undo entry. */
+    finishGroup(group) {
+        this.#assertNotPublishing();
+        this.#assertSynchronized();
+        const entry = this.#undo.at(-1);
+        if (entry?.group !== group)
+            return;
+        this.#undo[this.#undo.length - 1] = {
+            ...(entry.label === undefined ? {} : { label: entry.label }),
+            operations: entry.operations,
+            inverse: entry.inverse,
+        };
+    }
+    /** Reverts the active group without creating redo history. */
+    cancelGroup(group) {
+        this.#assertNotPublishing();
+        this.#assertSynchronized();
+        const entry = this.#undo.at(-1);
+        if (entry === undefined)
+            return null;
+        if (entry.group !== group) {
+            throw historyError('HISTORY_GROUP_NOT_ACTIVE', `History group ${group} is not active`);
+        }
+        const commit = this.#engine.edit({
+            baseRevision: this.#engine.revision,
+            label: entry.label === undefined ? 'Cancel interactive edit' : `Cancel: ${entry.label}`,
+        }, transaction => transaction.appendOperations(entry.inverse));
+        this.#undo.pop();
+        this.#expectedRevision = commit.revision;
+        this.#notify(commit);
+        return commit;
+    }
+    undo() {
+        this.#assertNotPublishing();
+        this.#assertSynchronized();
+        const entry = this.#undo.at(-1);
+        if (entry === undefined)
+            throw historyError('HISTORY_UNDO_EMPTY', 'There is no edit to undo');
+        const commit = this.#engine.edit({
+            baseRevision: this.#engine.revision,
+            label: entry.label === undefined ? 'Undo' : `Undo: ${entry.label}`,
+        }, transaction => transaction.appendOperations(entry.inverse));
+        this.#undo.pop();
+        this.#redo.push(entry);
+        this.#trim(this.#redo);
+        this.#expectedRevision = commit.revision;
+        this.#notify(commit);
+        return commit;
+    }
+    redo() {
+        this.#assertNotPublishing();
+        this.#assertSynchronized();
+        const entry = this.#redo.at(-1);
+        if (entry === undefined)
+            throw historyError('HISTORY_REDO_EMPTY', 'There is no edit to redo');
+        const commit = this.#engine.edit({
+            baseRevision: this.#engine.revision,
+            label: entry.label === undefined ? 'Redo' : `Redo: ${entry.label}`,
+        }, transaction => transaction.appendOperations(entry.operations));
+        this.#redo.pop();
+        this.#undo.push(entry);
+        this.#trim(this.#undo);
+        this.#expectedRevision = commit.revision;
+        this.#notify(commit);
+        return commit;
+    }
+    clear() {
+        this.#assertNotPublishing();
+        this.#undo.length = 0;
+        this.#redo.length = 0;
+        this.#expectedRevision = this.#engine.revision;
+    }
+    #assertSynchronized() {
+        if (this.#engine.revision === this.#expectedRevision)
+            return;
+        throw historyError('HISTORY_REVISION_DIVERGED', `History expected revision ${this.#expectedRevision}, current revision is ${this.#engine.revision}`);
+    }
+    #trim(entries) {
+        const overflow = entries.length - this.#maxEntries;
+        if (overflow > 0)
+            entries.splice(0, overflow);
+    }
+    #assertNotPublishing() {
+        if (!this.#publishing)
+            return;
+        throw historyError('HISTORY_REENTRANT', 'History cannot be mutated while a committed change is being published');
+    }
+    #notify(commit) {
+        this.#publishing = true;
+        try {
+            for (const listener of [...this.#listeners]) {
+                try {
+                    listener(commit);
+                }
+                catch {
+                    // History is already synchronized; observers cannot make it diverge.
+                }
+            }
+        }
+        finally {
+            this.#publishing = false;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './affected-ranges.js';
+export * from './commands.js';
+export * from './history.js';
+export * from './operations.js';
+export * from './transaction.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './affected-ranges.js';
+export * from './commands.js';
+export * from './history.js';
+export * from './operations.js';
+export * from './transaction.js';
+export * from './types.js';

package/dist/operations.d.ts

@@ -0,0 +1,5 @@
+import type { AelionProject } from '@aelionsdk/project-schema';
+import type { AtomicOperation } from './types.js';
+export declare function applyOperation(project: AelionProject, operation: AtomicOperation): AtomicOperation;
+export declare function applyOperations(project: AelionProject, operations: readonly AtomicOperation[]): readonly AtomicOperation[];
+//# sourceMappingURL=operations.d.ts.map

package/dist/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../src/operations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAiB,MAAM,2BAA2B,CAAC;AAE9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AA+GlD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,aAAa,EACtB,SAAS,EAAE,eAAe,GACzB,eAAe,CAyJjB;AAED,wBAAgB,eAAe,CAC7B,OAAO,EAAE,aAAa,EACtB,UAAU,EAAE,SAAS,eAAe,EAAE,GACrC,SAAS,eAAe,EAAE,CAM5B"}

package/dist/operations.js

@@ -0,0 +1,187 @@
+import { AelionError } from '@aelionsdk/core';
+function operationError(code, message, operation) {
+    return new AelionError([
+        {
+            code,
+            severity: 'error',
+            message,
+            path: [operation.collection, operation.id, ...('path' in operation ? operation.path : [])],
+            entityId: operation.id,
+            recoverable: true,
+        },
+    ]);
+}
+function cloneValue(value) {
+    return structuredClone(value);
+}
+function getEntity(project, operation) {
+    const entity = project[operation.collection][operation.id];
+    if (entity === undefined) {
+        throw operationError('TRANSACTION_ENTITY_MISSING', `${operation.collection}/${operation.id} does not exist`, operation);
+    }
+    return entity;
+}
+function resolveTarget(entity, path, operation) {
+    if (path.length === 0) {
+        throw operationError('TRANSACTION_PATH_INVALID', 'Field path must contain at least one segment', operation);
+    }
+    let current = entity;
+    for (const segment of path.slice(0, -1)) {
+        const next = current[segment];
+        if (next === null || Array.isArray(next) || typeof next !== 'object') {
+            throw operationError('TRANSACTION_PATH_INVALID', `Path segment ${segment} is not an object`, operation);
+        }
+        current = next;
+    }
+    const key = path.at(-1);
+    if (key === undefined) {
+        throw operationError('TRANSACTION_PATH_INVALID', 'Field path must contain at least one segment', operation);
+    }
+    return { parent: current, key };
+}
+function getList(entity, path, operation) {
+    const { parent, key } = resolveTarget(entity, path, operation);
+    const value = parent[key];
+    if (!Array.isArray(value) || value.some(entry => typeof entry !== 'string')) {
+        throw operationError('TRANSACTION_LIST_INVALID', `Field ${path.join('.')} is not a string ID list`, operation);
+    }
+    return value;
+}
+function insertionIndex(list, beforeId, operation) {
+    if (beforeId === undefined)
+        return list.length;
+    const index = list.indexOf(beforeId);
+    if (index < 0) {
+        throw operationError('TRANSACTION_LIST_ANCHOR_MISSING', `List anchor ${beforeId} does not exist`, operation);
+    }
+    return index;
+}
+function nextId(list, index) {
+    return list[index + 1];
+}
+export function applyOperation(project, operation) {
+    const collection = project[operation.collection];
+    switch (operation.op) {
+        case 'createEntity': {
+            if (collection[operation.id] !== undefined) {
+                throw operationError('TRANSACTION_ENTITY_EXISTS', `${operation.collection}/${operation.id} already exists`, operation);
+            }
+            if (operation.value.id !== operation.id) {
+                throw operationError('TRANSACTION_ENTITY_ID_MISMATCH', 'Entity value.id must match operation id', operation);
+            }
+            collection[operation.id] = cloneValue(operation.value);
+            return {
+                op: 'deleteEntity',
+                collection: operation.collection,
+                id: operation.id,
+            };
+        }
+        case 'deleteEntity': {
+            const entity = getEntity(project, operation);
+            Reflect.deleteProperty(collection, operation.id);
+            return {
+                op: 'createEntity',
+                collection: operation.collection,
+                id: operation.id,
+                value: cloneValue(entity),
+            };
+        }
+        case 'setField': {
+            const entity = getEntity(project, operation);
+            const { parent, key } = resolveTarget(entity, operation.path, operation);
+            const existed = Object.hasOwn(parent, key);
+            const previous = parent[key];
+            parent[key] = cloneValue(operation.value);
+            if (!existed) {
+                return {
+                    op: 'removeField',
+                    collection: operation.collection,
+                    id: operation.id,
+                    path: operation.path,
+                };
+            }
+            return {
+                op: 'setField',
+                collection: operation.collection,
+                id: operation.id,
+                path: operation.path,
+                value: cloneValue(previous),
+            };
+        }
+        case 'removeField': {
+            const entity = getEntity(project, operation);
+            const { parent, key } = resolveTarget(entity, operation.path, operation);
+            if (!Object.hasOwn(parent, key)) {
+                throw operationError('TRANSACTION_FIELD_MISSING', `Field ${operation.path.join('.')} does not exist`, operation);
+            }
+            const previous = parent[key];
+            Reflect.deleteProperty(parent, key);
+            return {
+                op: 'setField',
+                collection: operation.collection,
+                id: operation.id,
+                path: operation.path,
+                value: cloneValue(previous),
+            };
+        }
+        case 'listInsert': {
+            const list = getList(getEntity(project, operation), operation.path, operation);
+            if (list.includes(operation.valueId)) {
+                throw operationError('TRANSACTION_LIST_DUPLICATE', `List already contains ${operation.valueId}`, operation);
+            }
+            list.splice(insertionIndex(list, operation.beforeId, operation), 0, operation.valueId);
+            return {
+                op: 'listRemove',
+                collection: operation.collection,
+                id: operation.id,
+                path: operation.path,
+                valueId: operation.valueId,
+            };
+        }
+        case 'listRemove': {
+            const list = getList(getEntity(project, operation), operation.path, operation);
+            const index = list.indexOf(operation.valueId);
+            if (index < 0) {
+                throw operationError('TRANSACTION_LIST_VALUE_MISSING', `List does not contain ${operation.valueId}`, operation);
+            }
+            const beforeId = nextId(list, index);
+            list.splice(index, 1);
+            return {
+                op: 'listInsert',
+                collection: operation.collection,
+                id: operation.id,
+                path: operation.path,
+                ...(beforeId === undefined ? {} : { beforeId }),
+                valueId: operation.valueId,
+            };
+        }
+        case 'listMove': {
+            const list = getList(getEntity(project, operation), operation.path, operation);
+            const sourceIndex = list.indexOf(operation.valueId);
+            if (sourceIndex < 0) {
+                throw operationError('TRANSACTION_LIST_VALUE_MISSING', `List does not contain ${operation.valueId}`, operation);
+            }
+            if (operation.beforeId === operation.valueId) {
+                throw operationError('TRANSACTION_LIST_ANCHOR_INVALID', 'A list entry cannot be moved before itself', operation);
+            }
+            const previousBeforeId = nextId(list, sourceIndex);
+            list.splice(sourceIndex, 1);
+            list.splice(insertionIndex(list, operation.beforeId, operation), 0, operation.valueId);
+            return {
+                op: 'listMove',
+                collection: operation.collection,
+                id: operation.id,
+                path: operation.path,
+                ...(previousBeforeId === undefined ? {} : { beforeId: previousBeforeId }),
+                valueId: operation.valueId,
+            };
+        }
+    }
+}
+export function applyOperations(project, operations) {
+    const inverse = [];
+    for (const operation of operations) {
+        inverse.unshift(applyOperation(project, operation));
+    }
+    return inverse;
+}

package/dist/transaction.d.ts

@@ -0,0 +1,32 @@
+import type { JsonObject, JsonValue } from '@aelionsdk/core';
+import { type AelionProject, type CollectionName, type EntityId } from '@aelionsdk/project-schema';
+import type { AtomicOperation, ChangeSet, EditOptions, ProjectChangeListener, ProjectValidation, TransactionCommit, TransactionEngineOptions } from './types.js';
+export declare const TRANSACTION_MAX_OPERATIONS = 16384;
+export declare class TransactionBuilder {
+    #private;
+    get operations(): readonly AtomicOperation[];
+    /**
+     * Appends an already validated operation sequence to this transaction.
+     *
+     * This is primarily used by history/replay adapters. Operations are cloned so
+     * callers cannot mutate a transaction after it has been committed.
+     */
+    appendOperations(operations: readonly AtomicOperation[]): void;
+    createEntity(collection: CollectionName, id: EntityId, value: JsonObject): void;
+    deleteEntity(collection: CollectionName, id: EntityId): void;
+    setField(collection: CollectionName, id: EntityId, path: readonly string[], value: JsonValue): void;
+    removeField(collection: CollectionName, id: EntityId, path: readonly string[]): void;
+    listInsert(collection: CollectionName, id: EntityId, path: readonly string[], valueId: EntityId, beforeId?: EntityId): void;
+    listRemove(collection: CollectionName, id: EntityId, path: readonly string[], valueId: EntityId): void;
+    listMove(collection: CollectionName, id: EntityId, path: readonly string[], valueId: EntityId, beforeId?: EntityId): void;
+}
+export declare class TransactionEngine {
+    #private;
+    constructor(project: AelionProject, validate: ProjectValidation, options?: TransactionEngineOptions);
+    get revision(): bigint;
+    getSnapshot(): Readonly<AelionProject>;
+    subscribe(listener: ProjectChangeListener): () => void;
+    edit(options: EditOptions, callback: (transaction: TransactionBuilder) => void): TransactionCommit;
+    applyChangeSet(changeSet: ChangeSet): TransactionCommit;
+}
+//# sourceMappingURL=transaction.d.ts.map

package/dist/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE7D,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,QAAQ,EACd,MAAM,2BAA2B,CAAC;AAInC,OAAO,KAAK,EACV,eAAe,EACf,SAAS,EACT,WAAW,EACX,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AA8CpB,eAAO,MAAM,0BAA0B,QAAS,CAAC;AAOjD,qBAAa,kBAAkB;;IAG7B,IAAW,UAAU,IAAI,SAAS,eAAe,EAAE,CAElD;IAED;;;;;OAKG;IACI,gBAAgB,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,GAAG,IAAI;IAU9D,YAAY,CAAC,UAAU,EAAE,cAAc,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI;IAI/E,YAAY,CAAC,UAAU,EAAE,cAAc,EAAE,EAAE,EAAE,QAAQ,GAAG,IAAI;IAI5D,QAAQ,CACb,UAAU,EAAE,cAAc,EAC1B,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,KAAK,EAAE,SAAS,GACf,IAAI;IAIA,WAAW,CAAC,UAAU,EAAE,cAAc,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAIpF,UAAU,CACf,UAAU,EAAE,cAAc,EAC1B,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,QAAQ,EACjB,QAAQ,CAAC,EAAE,QAAQ,GAClB,IAAI;IAWA,UAAU,CACf,UAAU,EAAE,cAAc,EAC1B,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,QAAQ,GAChB,IAAI;IAIA,QAAQ,CACb,UAAU,EAAE,cAAc,EAC1B,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,QAAQ,EACjB,QAAQ,CAAC,EAAE,QAAQ,GAClB,IAAI;CAoBR;AAED,qBAAa,iBAAiB;;gBAU1B,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,GAAE,wBAA6B;IAUxC,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAEM,WAAW,IAAI,QAAQ,CAAC,aAAa,CAAC;IAItC,SAAS,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,IAAI;IAKtD,IAAI,CACT,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,CAAC,WAAW,EAAE,kBAAkB,KAAK,IAAI,GAClD,iBAAiB;IAiFb,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,iBAAiB;CA2B/D"}