@revealui/ai 0.1.0

package/dist/memory/crdt/pn-counter.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Positive-Negative Counter (PN-Counter)
+ *
+ * A CRDT counter that supports both increment and decrement operations.
+ * Uses two G-Counters (grow-only counters) internally: one for increments
+ * and one for decrements.
+ *
+ * Use cases:
+ * - Access counts
+ * - Usage metrics
+ * - Voting systems
+ * - Inventory tracking
+ *
+ * @example
+ * ```typescript
+ * const counter1 = new PNCounter('node-a')
+ * const counter2 = new PNCounter('node-b')
+ *
+ * counter1.increment(5)
+ * counter2.increment(3)
+ * counter2.decrement(2)
+ *
+ * const merged = counter1.merge(counter2)
+ * const total = merged.value() // 6 (5 + 3 - 2)
+ * ```
+ */
+export interface PNCounterData {
+    nodeId: string;
+    increments: Record<string, number>;
+    decrements: Record<string, number>;
+}
+export declare class PNCounter {
+    private nodeId;
+    private increments;
+    private decrements;
+    /**
+     * Creates a new PN-Counter.
+     * @param nodeId - Unique identifier for this node
+     */
+    constructor(nodeId: string);
+    /**
+     * Increments the counter.
+     * @param delta - Amount to increment by (default: 1)
+     */
+    increment(delta?: number): void;
+    /**
+     * Decrements the counter.
+     * @param delta - Amount to decrement by (default: 1)
+     */
+    decrement(delta?: number): void;
+    /**
+     * Gets the current value of the counter.
+     * @returns The sum of all increments minus the sum of all decrements
+     */
+    value(): number;
+    /**
+     * Gets the total increment count.
+     */
+    totalIncrements(): number;
+    /**
+     * Gets the total decrement count.
+     */
+    totalDecrements(): number;
+    /**
+     * Gets the increment count for a specific node.
+     * @param nodeId - The node ID to query
+     */
+    getIncrement(nodeId: string): number;
+    /**
+     * Gets the decrement count for a specific node.
+     * @param nodeId - The node ID to query
+     */
+    getDecrement(nodeId: string): number;
+    /**
+     * Merges another PN-Counter into this one.
+     * Takes the maximum of each node's counters.
+     * @param other - The counter to merge
+     * @returns A new merged PNCounter
+     */
+    merge(other: PNCounter): PNCounter;
+    /**
+     * Resets this node's counters to zero.
+     * Note: This doesn't affect the overall value if other nodes have contributions.
+     */
+    reset(): void;
+    /**
+     * Creates a copy of this counter.
+     * @returns A new PNCounter with the same state
+     */
+    clone(): PNCounter;
+    /**
+     * Serializes the counter to a plain object.
+     * @returns A serializable representation
+     */
+    toData(): PNCounterData;
+    /**
+     * Deserializes a counter from serialized data.
+     * @param data - The serialized counter data
+     * @returns A new PNCounter instance
+     */
+    static fromData(data: PNCounterData): PNCounter;
+    /**
+     * Creates a new counter with a generated node ID.
+     * @returns A new PNCounter with a UUID node ID
+     */
+    static create(): PNCounter;
+    /**
+     * Gets all contributing node IDs.
+     */
+    get nodes(): string[];
+    /**
+     * Returns a string representation for debugging.
+     */
+    toString(): string;
+}
+//# sourceMappingURL=pn-counter.d.ts.map

package/dist/memory/crdt/pn-counter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pn-counter.d.ts","sourceRoot":"","sources":["../../../src/memory/crdt/pn-counter.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACnC;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,UAAU,CAAqB;IAEvC;;;OAGG;gBACS,MAAM,EAAE,MAAM;IAU1B;;;OAGG;IACH,SAAS,CAAC,KAAK,GAAE,MAAU,GAAG,IAAI;IAQlC;;;OAGG;IACH,SAAS,CAAC,KAAK,GAAE,MAAU,GAAG,IAAI;IAQlC;;;OAGG;IACH,KAAK,IAAI,MAAM;IAaf;;OAEG;IACH,eAAe,IAAI,MAAM;IAQzB;;OAEG;IACH,eAAe,IAAI,MAAM;IAQzB;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAIpC;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAIpC;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS;IA0BlC;;;OAGG;IACH,KAAK,IAAI,IAAI;IAKb;;;OAGG;IACH,KAAK,IAAI,SAAS;IAOlB;;;OAGG;IACH,MAAM,IAAI,aAAa;IAQvB;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS;IAO/C;;;OAGG;IACH,MAAM,CAAC,MAAM,IAAI,SAAS;IAI1B;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,EAAE,CAEpB;IAED;;OAEG;IACH,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/memory/crdt/pn-counter.js

@@ -0,0 +1,174 @@
+import { randomUUID } from 'node:crypto';
+export class PNCounter {
+    nodeId;
+    increments;
+    decrements;
+    /**
+     * Creates a new PN-Counter.
+     * @param nodeId - Unique identifier for this node
+     */
+    constructor(nodeId) {
+        this.nodeId = nodeId;
+        this.increments = new Map();
+        this.decrements = new Map();
+        // Initialize this node's counters
+        this.increments.set(nodeId, 0);
+        this.decrements.set(nodeId, 0);
+    }
+    /**
+     * Increments the counter.
+     * @param delta - Amount to increment by (default: 1)
+     */
+    increment(delta = 1) {
+        if (delta < 0) {
+            throw new Error('Increment delta must be non-negative. Use decrement for negative values.');
+        }
+        const current = this.increments.get(this.nodeId) ?? 0;
+        this.increments.set(this.nodeId, current + delta);
+    }
+    /**
+     * Decrements the counter.
+     * @param delta - Amount to decrement by (default: 1)
+     */
+    decrement(delta = 1) {
+        if (delta < 0) {
+            throw new Error('Decrement delta must be non-negative. Use increment for negative values.');
+        }
+        const current = this.decrements.get(this.nodeId) ?? 0;
+        this.decrements.set(this.nodeId, current + delta);
+    }
+    /**
+     * Gets the current value of the counter.
+     * @returns The sum of all increments minus the sum of all decrements
+     */
+    value() {
+        let total = 0;
+        for (const inc of this.increments.values()) {
+            total += inc;
+        }
+        for (const dec of this.decrements.values()) {
+            total -= dec;
+        }
+        return total;
+    }
+    /**
+     * Gets the total increment count.
+     */
+    totalIncrements() {
+        let total = 0;
+        for (const inc of this.increments.values()) {
+            total += inc;
+        }
+        return total;
+    }
+    /**
+     * Gets the total decrement count.
+     */
+    totalDecrements() {
+        let total = 0;
+        for (const dec of this.decrements.values()) {
+            total += dec;
+        }
+        return total;
+    }
+    /**
+     * Gets the increment count for a specific node.
+     * @param nodeId - The node ID to query
+     */
+    getIncrement(nodeId) {
+        return this.increments.get(nodeId) ?? 0;
+    }
+    /**
+     * Gets the decrement count for a specific node.
+     * @param nodeId - The node ID to query
+     */
+    getDecrement(nodeId) {
+        return this.decrements.get(nodeId) ?? 0;
+    }
+    /**
+     * Merges another PN-Counter into this one.
+     * Takes the maximum of each node's counters.
+     * @param other - The counter to merge
+     * @returns A new merged PNCounter
+     */
+    merge(other) {
+        const merged = new PNCounter(this.nodeId);
+        // Get all unique node IDs
+        const allNodes = new Set([
+            ...this.increments.keys(),
+            ...this.decrements.keys(),
+            ...other.increments.keys(),
+            ...other.decrements.keys(),
+        ]);
+        for (const nodeId of allNodes) {
+            // Max of increments
+            const thisInc = this.increments.get(nodeId) ?? 0;
+            const otherInc = other.increments.get(nodeId) ?? 0;
+            merged.increments.set(nodeId, Math.max(thisInc, otherInc));
+            // Max of decrements
+            const thisDec = this.decrements.get(nodeId) ?? 0;
+            const otherDec = other.decrements.get(nodeId) ?? 0;
+            merged.decrements.set(nodeId, Math.max(thisDec, otherDec));
+        }
+        return merged;
+    }
+    /**
+     * Resets this node's counters to zero.
+     * Note: This doesn't affect the overall value if other nodes have contributions.
+     */
+    reset() {
+        this.increments.set(this.nodeId, 0);
+        this.decrements.set(this.nodeId, 0);
+    }
+    /**
+     * Creates a copy of this counter.
+     * @returns A new PNCounter with the same state
+     */
+    clone() {
+        const cloned = new PNCounter(this.nodeId);
+        cloned.increments = new Map(this.increments);
+        cloned.decrements = new Map(this.decrements);
+        return cloned;
+    }
+    /**
+     * Serializes the counter to a plain object.
+     * @returns A serializable representation
+     */
+    toData() {
+        return {
+            nodeId: this.nodeId,
+            increments: Object.fromEntries(this.increments),
+            decrements: Object.fromEntries(this.decrements),
+        };
+    }
+    /**
+     * Deserializes a counter from serialized data.
+     * @param data - The serialized counter data
+     * @returns A new PNCounter instance
+     */
+    static fromData(data) {
+        const counter = new PNCounter(data.nodeId);
+        counter.increments = new Map(Object.entries(data.increments));
+        counter.decrements = new Map(Object.entries(data.decrements));
+        return counter;
+    }
+    /**
+     * Creates a new counter with a generated node ID.
+     * @returns A new PNCounter with a UUID node ID
+     */
+    static create() {
+        return new PNCounter(randomUUID());
+    }
+    /**
+     * Gets all contributing node IDs.
+     */
+    get nodes() {
+        return Array.from(new Set([...this.increments.keys(), ...this.decrements.keys()]));
+    }
+    /**
+     * Returns a string representation for debugging.
+     */
+    toString() {
+        return `PNCounter(value=${this.value()}, inc=${this.totalIncrements()}, dec=${this.totalDecrements()})`;
+    }
+}

package/dist/memory/crdt/vector-clock.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Vector Clock for causal ordering across distributed nodes.
+ *
+ * A vector clock is a mechanism for tracking causality in distributed systems.
+ * Each node maintains a counter, and the clock can determine if one event
+ * happened before, after, or concurrently with another event.
+ *
+ * @example
+ * ```typescript
+ * const clock1 = new VectorClock('node-a')
+ * clock1.tick('node-a') // { 'node-a': 1 }
+ *
+ * const clock2 = new VectorClock('node-b')
+ * clock2.tick('node-b') // { 'node-b': 1 }
+ *
+ * // Concurrent events
+ * clock1.compare(clock2) // 'concurrent'
+ *
+ * // After merge
+ * clock1.merge(clock2)
+ * clock1.tick('node-a')
+ * clock1.compare(clock2) // 'after'
+ * ```
+ */
+export interface VectorClockData {
+    clock: Record<string, number>;
+}
+export type VectorClockComparison = 'before' | 'after' | 'concurrent' | 'equal';
+export declare class VectorClock {
+    private clock;
+    private nodeId;
+    /**
+     * Creates a new VectorClock instance.
+     * @param nodeId - Unique identifier for this node
+     */
+    constructor(nodeId: string);
+    /**
+     * Increments the clock for a specific node.
+     * Typically called when this node performs an operation.
+     * @param nodeId - The node ID to increment (defaults to this node)
+     */
+    tick(nodeId?: string): void;
+    /**
+     * Gets the current timestamp for a specific node.
+     * @param nodeId - The node ID to query
+     * @returns The current timestamp for the node, or 0 if not present
+     */
+    get(nodeId: string): number;
+    /**
+     * Gets the timestamp for this node.
+     * @returns The current timestamp for this node
+     */
+    getLocal(): number;
+    /**
+     * Merges another vector clock into this one.
+     * Takes the maximum of each node's counter.
+     * @param other - The vector clock to merge
+     */
+    merge(other: VectorClock): void;
+    /**
+     * Compares this vector clock with another.
+     * @param other - The vector clock to compare against
+     * @returns The comparison result:
+     *   - 'before': this happened before other
+     *   - 'after': this happened after other
+     *   - 'concurrent': events are concurrent (no causal relationship)
+     *   - 'equal': clocks are identical
+     */
+    compare(other: VectorClock): VectorClockComparison;
+    /**
+     * Checks if this clock happened before another.
+     * @param other - The vector clock to compare against
+     */
+    happenedBefore(other: VectorClock): boolean;
+    /**
+     * Checks if this clock happened after another.
+     * @param other - The vector clock to compare against
+     */
+    happenedAfter(other: VectorClock): boolean;
+    /**
+     * Checks if this clock is concurrent with another.
+     * @param other - The vector clock to compare against
+     */
+    isConcurrent(other: VectorClock): boolean;
+    /**
+     * Creates a copy of this vector clock.
+     * @returns A new VectorClock with the same state
+     */
+    clone(): VectorClock;
+    /**
+     * Serializes the vector clock to a plain object.
+     * @returns A serializable representation of the clock
+     */
+    toData(): VectorClockData;
+    /**
+     * Deserializes a vector clock from serialized data.
+     * @param data - The serialized clock data
+     * @param nodeId - The node ID for the new clock instance
+     * @returns A new VectorClock instance
+     */
+    static fromData(data: VectorClockData, nodeId: string): VectorClock;
+    /**
+     * Gets the total number of nodes tracked by this clock.
+     */
+    get size(): number;
+    /**
+     * Gets all node IDs tracked by this clock.
+     */
+    get nodes(): string[];
+    /**
+     * Returns a string representation for debugging.
+     */
+    toString(): string;
+}
+//# sourceMappingURL=vector-clock.d.ts.map

package/dist/memory/crdt/vector-clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-clock.d.ts","sourceRoot":"","sources":["../../../src/memory/crdt/vector-clock.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC9B;AAED,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,OAAO,GAAG,YAAY,GAAG,OAAO,CAAA;AAE/E,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,MAAM,CAAQ;IAEtB;;;OAGG;gBACS,MAAM,EAAE,MAAM;IAM1B;;;;OAIG;IACH,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAM3B;;;;OAIG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAI3B;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;OAIG;IACH,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAO/B;;;;;;;;OAQG;IACH,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,qBAAqB;IA+BlD;;;OAGG;IACH,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO;IAI3C;;;OAGG;IACH,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO;IAI1C;;;OAGG;IACH,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO;IAIzC;;;OAGG;IACH,KAAK,IAAI,WAAW;IAMpB;;;OAGG;IACH,MAAM,IAAI,eAAe;IAMzB;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW;IAMnE;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,EAAE,CAEpB;IAED;;OAEG;IACH,QAAQ,IAAI,MAAM;CAMnB"}

package/dist/memory/crdt/vector-clock.js

@@ -0,0 +1,179 @@
+/**
+ * Vector Clock for causal ordering across distributed nodes.
+ *
+ * A vector clock is a mechanism for tracking causality in distributed systems.
+ * Each node maintains a counter, and the clock can determine if one event
+ * happened before, after, or concurrently with another event.
+ *
+ * @example
+ * ```typescript
+ * const clock1 = new VectorClock('node-a')
+ * clock1.tick('node-a') // { 'node-a': 1 }
+ *
+ * const clock2 = new VectorClock('node-b')
+ * clock2.tick('node-b') // { 'node-b': 1 }
+ *
+ * // Concurrent events
+ * clock1.compare(clock2) // 'concurrent'
+ *
+ * // After merge
+ * clock1.merge(clock2)
+ * clock1.tick('node-a')
+ * clock1.compare(clock2) // 'after'
+ * ```
+ */
+export class VectorClock {
+    clock;
+    nodeId;
+    /**
+     * Creates a new VectorClock instance.
+     * @param nodeId - Unique identifier for this node
+     */
+    constructor(nodeId) {
+        this.nodeId = nodeId;
+        this.clock = new Map();
+        this.clock.set(nodeId, 0);
+    }
+    /**
+     * Increments the clock for a specific node.
+     * Typically called when this node performs an operation.
+     * @param nodeId - The node ID to increment (defaults to this node)
+     */
+    tick(nodeId) {
+        const id = nodeId ?? this.nodeId;
+        const current = this.clock.get(id) ?? 0;
+        this.clock.set(id, current + 1);
+    }
+    /**
+     * Gets the current timestamp for a specific node.
+     * @param nodeId - The node ID to query
+     * @returns The current timestamp for the node, or 0 if not present
+     */
+    get(nodeId) {
+        return this.clock.get(nodeId) ?? 0;
+    }
+    /**
+     * Gets the timestamp for this node.
+     * @returns The current timestamp for this node
+     */
+    getLocal() {
+        return this.get(this.nodeId);
+    }
+    /**
+     * Merges another vector clock into this one.
+     * Takes the maximum of each node's counter.
+     * @param other - The vector clock to merge
+     */
+    merge(other) {
+        for (const [nodeId, timestamp] of other.clock) {
+            const current = this.clock.get(nodeId) ?? 0;
+            this.clock.set(nodeId, Math.max(current, timestamp));
+        }
+    }
+    /**
+     * Compares this vector clock with another.
+     * @param other - The vector clock to compare against
+     * @returns The comparison result:
+     *   - 'before': this happened before other
+     *   - 'after': this happened after other
+     *   - 'concurrent': events are concurrent (no causal relationship)
+     *   - 'equal': clocks are identical
+     */
+    compare(other) {
+        let lessThan = false;
+        let greaterThan = false;
+        // Get all unique node IDs
+        const allNodes = new Set([...this.clock.keys(), ...other.clock.keys()]);
+        for (const nodeId of allNodes) {
+            const thisValue = this.clock.get(nodeId) ?? 0;
+            const otherValue = other.clock.get(nodeId) ?? 0;
+            if (thisValue < otherValue) {
+                lessThan = true;
+            }
+            if (thisValue > otherValue) {
+                greaterThan = true;
+            }
+        }
+        if (lessThan && greaterThan) {
+            return 'concurrent';
+        }
+        if (lessThan) {
+            return 'before';
+        }
+        if (greaterThan) {
+            return 'after';
+        }
+        return 'equal';
+    }
+    /**
+     * Checks if this clock happened before another.
+     * @param other - The vector clock to compare against
+     */
+    happenedBefore(other) {
+        return this.compare(other) === 'before';
+    }
+    /**
+     * Checks if this clock happened after another.
+     * @param other - The vector clock to compare against
+     */
+    happenedAfter(other) {
+        return this.compare(other) === 'after';
+    }
+    /**
+     * Checks if this clock is concurrent with another.
+     * @param other - The vector clock to compare against
+     */
+    isConcurrent(other) {
+        return this.compare(other) === 'concurrent';
+    }
+    /**
+     * Creates a copy of this vector clock.
+     * @returns A new VectorClock with the same state
+     */
+    clone() {
+        const cloned = new VectorClock(this.nodeId);
+        cloned.clock = new Map(this.clock);
+        return cloned;
+    }
+    /**
+     * Serializes the vector clock to a plain object.
+     * @returns A serializable representation of the clock
+     */
+    toData() {
+        return {
+            clock: Object.fromEntries(this.clock),
+        };
+    }
+    /**
+     * Deserializes a vector clock from serialized data.
+     * @param data - The serialized clock data
+     * @param nodeId - The node ID for the new clock instance
+     * @returns A new VectorClock instance
+     */
+    static fromData(data, nodeId) {
+        const clock = new VectorClock(nodeId);
+        clock.clock = new Map(Object.entries(data.clock));
+        return clock;
+    }
+    /**
+     * Gets the total number of nodes tracked by this clock.
+     */
+    get size() {
+        return this.clock.size;
+    }
+    /**
+     * Gets all node IDs tracked by this clock.
+     */
+    get nodes() {
+        return Array.from(this.clock.keys());
+    }
+    /**
+     * Returns a string representation for debugging.
+     */
+    toString() {
+        const entries = Array.from(this.clock.entries())
+            .map(([k, v]) => `${k}:${v}`)
+            .join(', ');
+        return `VectorClock(${entries})`;
+    }
+}

package/dist/memory/errors/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Memory System Errors
+ *
+ * Custom error classes for the memory system with proper error codes and types.
+ */
+/**
+ * Base error class for memory system errors
+ */
+export declare class MemoryError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    constructor(message: string, code: string, statusCode?: number);
+}
+/**
+ * Database connection errors
+ */
+export declare class DatabaseConnectionError extends MemoryError {
+    constructor(message?: string, originalError?: Error);
+}
+/**
+ * Database constraint violation errors
+ */
+export declare class DatabaseConstraintError extends MemoryError {
+    constructor(message?: string, originalError?: Error);
+}
+/**
+ * Database query/operation errors
+ */
+export declare class DatabaseOperationError extends MemoryError {
+    constructor(message?: string, originalError?: Error);
+}
+/**
+ * Validation errors
+ */
+export declare class ValidationError extends MemoryError {
+    constructor(message: string);
+}
+/**
+ * Not found errors
+ */
+export declare class NotFoundError extends MemoryError {
+    constructor(resource: string);
+}
+/**
+ * Configuration errors
+ */
+export declare class ConfigurationError extends MemoryError {
+    constructor(message: string);
+}
+/**
+ * Data migration errors
+ */
+export declare class MigrationError extends MemoryError {
+    constructor(message: string);
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/memory/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/memory/errors/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC,SAAgB,IAAI,EAAE,MAAM,CAAA;IAC5B,SAAgB,UAAU,EAAE,MAAM,CAAA;gBAEtB,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,SAAM;CAU5D;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,WAAW;gBAC1C,OAAO,SAA+B,EAAE,aAAa,CAAC,EAAE,KAAK;CAQ1E;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,WAAW;gBAC1C,OAAO,SAAkC,EAAE,aAAa,CAAC,EAAE,KAAK;CAQ7E;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,WAAW;gBACzC,OAAO,SAA8B,EAAE,aAAa,CAAC,EAAE,KAAK;CAQzE;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,WAAW;gBAClC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,aAAc,SAAQ,WAAW;gBAChC,QAAQ,EAAE,MAAM;CAI7B;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,WAAW;gBACrC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,cAAe,SAAQ,WAAW;gBACjC,OAAO,EAAE,MAAM;CAI5B"}