@danielsimonjr/memory-mcp 0.47.1 → 9.8.0

package/dist/core/EntityManager.js

@@ -2,20 +2,23 @@
  * Entity Manager
  *
  * Handles CRUD operations for entities in the knowledge graph.
+ * Focused on core entity and tag operations only (Phase 4: Consolidate God Objects).
  *
  * @module core/EntityManager
  */
 import { EntityNotFoundError, InvalidImportanceError, ValidationError } from '../utils/errors.js';
-import { BatchCreateEntitiesSchema, UpdateEntitySchema, EntityNamesSchema } from '../utils/index.js';
+import { BatchCreateEntitiesSchema, UpdateEntitySchema, EntityNamesSchema, checkCancellation, createProgressReporter, createProgress, } from '../utils/index.js';
 import { GRAPH_LIMITS } from '../utils/constants.js';
 /**
  * Minimum importance value (least important).
+ * Note: Use IMPORTANCE_RANGE from constants.ts for external access.
  */
-export const MIN_IMPORTANCE = 0;
+const MIN_IMPORTANCE = 0;
 /**
  * Maximum importance value (most important).
+ * Note: Use IMPORTANCE_RANGE from constants.ts for external access.
  */
-export const MAX_IMPORTANCE = 10;
+const MAX_IMPORTANCE = 10;
 /**
  * Manages entity operations with automatic timestamp handling.
  */
@@ -33,9 +36,13 @@ export class EntityManager {
      * - Normalizes all tags to lowercase for consistent searching
      * - Validates importance values (must be between 0-10)
      *
+     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
+     *
      * @param entities - Array of entities to create. Each entity must have a unique name.
+     * @param options - Optional progress/cancellation options (Phase 9B)
      * @returns Promise resolving to array of newly created entities (excludes duplicates)
      * @throws {InvalidImportanceError} If any entity has importance outside the valid range [0-10]
+     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
      *
      * @example
      * ```typescript
@@ -55,24 +62,43 @@ export class EntityManager {
      *   { name: 'Bob', entityType: 'person', observations: [] },
      *   { name: 'Charlie', entityType: 'person', observations: [] }
      * ]);
+     *
+     * // With progress tracking and cancellation (Phase 9B)
+     * const controller = new AbortController();
+     * const results = await manager.createEntities(largeEntityArray, {
+     *   signal: controller.signal,
+     *   onProgress: (p) => console.log(`${p.percentage}% complete`),
+     * });
      * ```
      */
-    async createEntities(entities) {
+    async createEntities(entities, options) {
+        // Check for early cancellation
+        checkCancellation(options?.signal, 'createEntities');
         // Validate input
         const validation = BatchCreateEntitiesSchema.safeParse(entities);
         if (!validation.success) {
             const errors = validation.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`);
             throw new ValidationError('Invalid entity data', errors);
         }
-        const graph = await this.storage.loadGraph();
+        // Setup progress reporter
+        const reportProgress = createProgressReporter(options?.onProgress);
+        const total = entities.length;
+        reportProgress?.(createProgress(0, total, 'createEntities'));
+        // Use read-only graph for checking existing entities
+        const readGraph = await this.storage.loadGraph();
         const timestamp = new Date().toISOString();
         // Check graph size limits
-        const entitiesToAdd = entities.filter(e => !graph.entities.some(existing => existing.name === e.name));
-        if (graph.entities.length + entitiesToAdd.length > GRAPH_LIMITS.MAX_ENTITIES) {
+        const entitiesToAdd = entities.filter(e => !readGraph.entities.some(existing => existing.name === e.name));
+        if (readGraph.entities.length + entitiesToAdd.length > GRAPH_LIMITS.MAX_ENTITIES) {
             throw new ValidationError('Graph size limit exceeded', [`Adding ${entitiesToAdd.length} entities would exceed maximum of ${GRAPH_LIMITS.MAX_ENTITIES} entities`]);
         }
-        const newEntities = entitiesToAdd
-            .map(e => {
+        // Check for cancellation before processing
+        checkCancellation(options?.signal, 'createEntities');
+        const newEntities = [];
+        let processed = 0;
+        for (const e of entitiesToAdd) {
+            // Check for cancellation periodically
+            checkCancellation(options?.signal, 'createEntities');
             const entity = {
                 ...e,
                 createdAt: e.createdAt || timestamp,
@@ -89,10 +115,22 @@ export class EntityManager {
                 }
                 entity.importance = e.importance;
             }
-            return entity;
-        });
-        graph.entities.push(...newEntities);
-        await this.storage.saveGraph(graph);
+            newEntities.push(entity);
+            processed++;
+            reportProgress?.(createProgress(processed, entitiesToAdd.length, 'createEntities'));
+        }
+        // OPTIMIZED: Use append for single entity, bulk save for multiple
+        // (N individual appends is slower than one bulk write)
+        if (newEntities.length === 1) {
+            await this.storage.appendEntity(newEntities[0]);
+        }
+        else if (newEntities.length > 1) {
+            const graph = await this.storage.getGraphForMutation();
+            graph.entities.push(...newEntities);
+            await this.storage.saveGraph(graph);
+        }
+        // Report completion
+        reportProgress?.(createProgress(entitiesToAdd.length, entitiesToAdd.length, 'createEntities'));
         return newEntities;
     }
     /**
@@ -127,9 +165,11 @@ export class EntityManager {
             const errors = validation.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`);
             throw new ValidationError('Invalid entity names', errors);
         }
-        const graph = await this.storage.loadGraph();
-        graph.entities = graph.entities.filter(e => !entityNames.includes(e.name));
-        graph.relations = graph.relations.filter(r => !entityNames.includes(r.from) && !entityNames.includes(r.to));
+        const graph = await this.storage.getGraphForMutation();
+        // OPTIMIZED: Use Set for O(1) lookups instead of O(n) includes()
+        const namesToDelete = new Set(entityNames);
+        graph.entities = graph.entities.filter(e => !namesToDelete.has(e.name));
+        graph.relations = graph.relations.filter(r => !namesToDelete.has(r.from) && !namesToDelete.has(r.to));
         await this.storage.saveGraph(graph);
     }
     /**
@@ -205,7 +245,7 @@ export class EntityManager {
             const errors = validation.error.issues.map((e) => `${e.path.join('.')}: ${e.message}`);
             throw new ValidationError('Invalid update data', errors);
         }
-        const graph = await this.storage.loadGraph();
+        const graph = await this.storage.getGraphForMutation();
         const entity = graph.entities.find(e => e.name === name);
         if (!entity) {
             throw new EntityNotFoundError(name);
@@ -258,14 +298,18 @@ export class EntityManager {
                 throw new ValidationError('Invalid update data', errors);
             }
         }
-        const graph = await this.storage.loadGraph();
+        const graph = await this.storage.getGraphForMutation();
         const timestamp = new Date().toISOString();
         const updatedEntities = [];
+        // OPTIMIZED: Build Map for O(1) lookups instead of O(n) find() per update
+        const entityIndex = new Map();
+        graph.entities.forEach((e, i) => entityIndex.set(e.name, i));
         for (const { name, updates: updateData } of updates) {
-            const entity = graph.entities.find(e => e.name === name);
-            if (!entity) {
+            const idx = entityIndex.get(name);
+            if (idx === undefined) {
                 throw new EntityNotFoundError(name);
             }
+            const entity = graph.entities[idx];
             // Apply updates
             Object.assign(entity, updateData);
             entity.lastModified = timestamp;
@@ -274,96 +318,9 @@ export class EntityManager {
         await this.storage.saveGraph(graph);
         return updatedEntities;
     }
-    /**
-     * Add observations to multiple entities in a single batch operation.
-     *
-     * This method performs the following operations:
-     * - Adds new observations to specified entities
-     * - Filters out duplicate observations (already present)
-     * - Updates lastModified timestamp only if new observations were added
-     *
-     * @param observations - Array of entity names and observations to add
-     * @returns Promise resolving to array of results showing which observations were added
-     * @throws {EntityNotFoundError} If any entity is not found
-     *
-     * @example
-     * ```typescript
-     * const manager = new EntityManager(storage);
-     *
-     * // Add observations to multiple entities
-     * const results = await manager.addObservations([
-     *   { entityName: 'Alice', contents: ['Completed project X', 'Started project Y'] },
-     *   { entityName: 'Bob', contents: ['Joined team meeting'] }
-     * ]);
-     *
-     * // Check what was added (duplicates are filtered out)
-     * results.forEach(r => {
-     *   console.log(`${r.entityName}: added ${r.addedObservations.length} new observations`);
-     * });
-     * ```
-     */
-    async addObservations(observations) {
-        const graph = await this.storage.loadGraph();
-        const timestamp = new Date().toISOString();
-        const results = observations.map(o => {
-            const entity = graph.entities.find(e => e.name === o.entityName);
-            if (!entity) {
-                throw new EntityNotFoundError(o.entityName);
-            }
-            const newObservations = o.contents.filter(content => !entity.observations.includes(content));
-            entity.observations.push(...newObservations);
-            // Update lastModified timestamp if observations were added
-            if (newObservations.length > 0) {
-                entity.lastModified = timestamp;
-            }
-            return { entityName: o.entityName, addedObservations: newObservations };
-        });
-        await this.storage.saveGraph(graph);
-        return results;
-    }
-    /**
-     * Delete observations from multiple entities in a single batch operation.
-     *
-     * This method performs the following operations:
-     * - Removes specified observations from entities
-     * - Updates lastModified timestamp only if observations were deleted
-     * - Silently ignores entities that don't exist (no error thrown)
-     *
-     * @param deletions - Array of entity names and observations to delete
-     * @returns Promise that resolves when deletion is complete
-     *
-     * @example
-     * ```typescript
-     * const manager = new EntityManager(storage);
-     *
-     * // Delete observations from multiple entities
-     * await manager.deleteObservations([
-     *   { entityName: 'Alice', observations: ['Old observation 1', 'Old observation 2'] },
-     *   { entityName: 'Bob', observations: ['Outdated info'] }
-     * ]);
-     *
-     * // Safe to delete from non-existent entities (no error)
-     * await manager.deleteObservations([
-     *   { entityName: 'NonExistent', observations: ['Some text'] }
-     * ]); // No error thrown
-     * ```
-     */
-    async deleteObservations(deletions) {
-        const graph = await this.storage.loadGraph();
-        const timestamp = new Date().toISOString();
-        deletions.forEach(d => {
-            const entity = graph.entities.find(e => e.name === d.entityName);
-            if (entity) {
-                const originalLength = entity.observations.length;
-                entity.observations = entity.observations.filter(o => !d.observations.includes(o));
-                // Update lastModified timestamp if observations were deleted
-                if (entity.observations.length < originalLength) {
-                    entity.lastModified = timestamp;
-                }
-            }
-        });
-        await this.storage.saveGraph(graph);
-    }
+    // ============================================================
+    // TAG OPERATIONS
+    // ============================================================
     /**
      * Add tags to an entity.
      *
@@ -375,25 +332,20 @@ export class EntityManager {
      * @throws {EntityNotFoundError} If entity is not found
      */
     async addTags(entityName, tags) {
-        const graph = await this.storage.loadGraph();
-        const timestamp = new Date().toISOString();
-        const entity = graph.entities.find(e => e.name === entityName);
+        // OPTIMIZED: Use O(1) NameIndex lookup instead of loadGraph() + O(n) find()
+        const entity = this.storage.getEntityByName(entityName);
         if (!entity) {
             throw new EntityNotFoundError(entityName);
         }
         // Initialize tags array if it doesn't exist
-        if (!entity.tags) {
-            entity.tags = [];
-        }
+        const existingTags = entity.tags || [];
         // Normalize tags to lowercase and filter out duplicates
         const normalizedTags = tags.map(tag => tag.toLowerCase());
-        const newTags = normalizedTags.filter(tag => !entity.tags.includes(tag));
-        entity.tags.push(...newTags);
-        // Update lastModified timestamp if tags were added
+        const newTags = normalizedTags.filter(tag => !existingTags.includes(tag));
         if (newTags.length > 0) {
-            entity.lastModified = timestamp;
+            // OPTIMIZED: Use updateEntity for in-place update + append
+            await this.storage.updateEntity(entityName, { tags: [...existingTags, ...newTags] });
         }
-        await this.storage.saveGraph(graph);
         return { entityName, addedTags: newTags };
     }
     /**
@@ -405,7 +357,7 @@ export class EntityManager {
      * @throws {EntityNotFoundError} If entity is not found
      */
     async removeTags(entityName, tags) {
-        const graph = await this.storage.loadGraph();
+        const graph = await this.storage.getGraphForMutation();
         const timestamp = new Date().toISOString();
         const entity = graph.entities.find(e => e.name === entityName);
         if (!entity) {
@@ -417,10 +369,12 @@ export class EntityManager {
         // Normalize tags to lowercase
         const normalizedTags = tags.map(tag => tag.toLowerCase());
         const originalLength = entity.tags.length;
+        // Capture existing tags (lowercase) BEFORE filtering to accurately track removals
+        const existingTagsLower = entity.tags.map(t => t.toLowerCase());
         // Filter out the tags to remove
         entity.tags = entity.tags.filter(tag => !normalizedTags.includes(tag.toLowerCase()));
-        const removedTags = normalizedTags.filter(tag => originalLength > entity.tags.length ||
-            !entity.tags.map(t => t.toLowerCase()).includes(tag));
+        // A tag was removed if it existed in the original tags
+        const removedTags = normalizedTags.filter(tag => existingTagsLower.includes(tag));
         // Update lastModified timestamp if tags were removed
         if (entity.tags.length < originalLength) {
             entity.lastModified = timestamp;
@@ -438,19 +392,17 @@ export class EntityManager {
      * @throws {Error} If importance is out of range
      */
     async setImportance(entityName, importance) {
-        const graph = await this.storage.loadGraph();
-        const timestamp = new Date().toISOString();
         // Validate importance range (0-10)
         if (importance < 0 || importance > 10) {
             throw new Error(`Importance must be between 0 and 10, got ${importance}`);
         }
-        const entity = graph.entities.find(e => e.name === entityName);
+        // OPTIMIZED: Use O(1) NameIndex lookup instead of loadGraph() + O(n) find()
+        const entity = this.storage.getEntityByName(entityName);
         if (!entity) {
             throw new EntityNotFoundError(entityName);
         }
-        entity.importance = importance;
-        entity.lastModified = timestamp;
-        await this.storage.saveGraph(graph);
+        // Use updateEntity for in-place update + append
+        await this.storage.updateEntity(entityName, { importance });
         return { entityName, importance };
     }
     /**
@@ -461,7 +413,7 @@ export class EntityManager {
      * @returns Array of results showing which tags were added to each entity
      */
     async addTagsToMultipleEntities(entityNames, tags) {
-        const graph = await this.storage.loadGraph();
+        const graph = await this.storage.getGraphForMutation();
         const timestamp = new Date().toISOString();
         const normalizedTags = tags.map(tag => tag.toLowerCase());
         const results = [];
@@ -494,7 +446,7 @@ export class EntityManager {
      * @returns Result with affected entities and count
      */
     async replaceTag(oldTag, newTag) {
-        const graph = await this.storage.loadGraph();
+        const graph = await this.storage.getGraphForMutation();
         const timestamp = new Date().toISOString();
         const normalizedOldTag = oldTag.toLowerCase();
         const normalizedNewTag = newTag.toLowerCase();
@@ -524,7 +476,7 @@ export class EntityManager {
      * @returns Object with affected entity names and count
      */
     async mergeTags(tag1, tag2, targetTag) {
-        const graph = await this.storage.loadGraph();
+        const graph = await this.storage.getGraphForMutation();
         const timestamp = new Date().toISOString();
         const normalizedTag1 = tag1.toLowerCase();
         const normalizedTag2 = tag2.toLowerCase();

package/dist/core/GraphEventEmitter.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Graph Event Emitter
+ *
+ * Phase 10 Sprint 2: Provides event-based notifications for graph changes.
+ * Enables loose coupling between graph operations and dependent systems
+ * like search indexes, analytics, and external integrations.
+ *
+ * @module core/GraphEventEmitter
+ */
+import type { GraphEventType, GraphEvent, GraphEventListener, GraphEventMap, Entity, Relation } from '../types/index.js';
+/**
+ * Phase 10 Sprint 2: Event emitter for graph change notifications.
+ *
+ * Provides a type-safe event system for subscribing to and emitting
+ * graph change events. Supports wildcard listeners for all events.
+ *
+ * @example
+ * ```typescript
+ * const emitter = new GraphEventEmitter();
+ *
+ * // Listen to specific event types
+ * emitter.on('entity:created', (event) => {
+ *   console.log(`Entity ${event.entity.name} created`);
+ * });
+ *
+ * // Listen to all events
+ * emitter.onAny((event) => {
+ *   console.log(`Event: ${event.type}`);
+ * });
+ *
+ * // Emit an event
+ * emitter.emitEntityCreated(entity);
+ *
+ * // Remove listener
+ * const unsubscribe = emitter.on('entity:deleted', handler);
+ * unsubscribe();
+ * ```
+ */
+export declare class GraphEventEmitter {
+    /**
+     * Map of event types to their registered listeners.
+     */
+    private listeners;
+    /**
+     * Listeners that receive all events regardless of type.
+     */
+    private wildcardListeners;
+    /**
+     * Whether to suppress errors from listeners (default: true).
+     * When true, listener errors are logged but don't stop event propagation.
+     */
+    private suppressListenerErrors;
+    /**
+     * Create a new GraphEventEmitter instance.
+     *
+     * @param options - Optional configuration
+     */
+    constructor(options?: {
+        suppressListenerErrors?: boolean;
+    });
+    /**
+     * Subscribe to a specific event type.
+     *
+     * @template K - The event type key
+     * @param eventType - The event type to listen for
+     * @param listener - Callback function to invoke when event occurs
+     * @returns Unsubscribe function to remove the listener
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = emitter.on('entity:created', (event) => {
+     *   console.log(`Created: ${event.entity.name}`);
+     * });
+     *
+     * // Later: unsubscribe();
+     * ```
+     */
+    on<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): () => void;
+    /**
+     * Unsubscribe from a specific event type.
+     *
+     * @template K - The event type key
+     * @param eventType - The event type to unsubscribe from
+     * @param listener - The listener function to remove
+     */
+    off<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): void;
+    /**
+     * Subscribe to all event types.
+     *
+     * @param listener - Callback function to invoke for any event
+     * @returns Unsubscribe function to remove the listener
+     *
+     * @example
+     * ```typescript
+     * emitter.onAny((event) => {
+     *   console.log(`Event: ${event.type} at ${event.timestamp}`);
+     * });
+     * ```
+     */
+    onAny(listener: GraphEventListener<GraphEvent>): () => void;
+    /**
+     * Unsubscribe from all events.
+     *
+     * @param listener - The listener function to remove
+     */
+    offAny(listener: GraphEventListener<GraphEvent>): void;
+    /**
+     * Subscribe to an event type, but only receive the first occurrence.
+     *
+     * @template K - The event type key
+     * @param eventType - The event type to listen for once
+     * @param listener - Callback function to invoke once
+     * @returns Unsubscribe function to cancel before event occurs
+     */
+    once<K extends GraphEventType>(eventType: K, listener: GraphEventListener<GraphEventMap[K]>): () => void;
+    /**
+     * Remove all listeners for all event types.
+     */
+    removeAllListeners(): void;
+    /**
+     * Get the count of listeners for a specific event type.
+     *
+     * @param eventType - The event type to count listeners for
+     * @returns Number of listeners registered
+     */
+    listenerCount(eventType?: GraphEventType): number;
+    /**
+     * Emit an event to all registered listeners.
+     *
+     * @param event - The event to emit
+     */
+    emit(event: GraphEvent): void;
+    /**
+     * Emit an entity:created event.
+     *
+     * @param entity - The entity that was created
+     */
+    emitEntityCreated(entity: Entity): void;
+    /**
+     * Emit an entity:updated event.
+     *
+     * @param entityName - Name of the updated entity
+     * @param changes - The changes that were applied
+     * @param previousValues - Optional previous values before update
+     */
+    emitEntityUpdated(entityName: string, changes: Partial<Entity>, previousValues?: Partial<Entity>): void;
+    /**
+     * Emit an entity:deleted event.
+     *
+     * @param entityName - Name of the deleted entity
+     * @param entity - Optional entity data before deletion
+     */
+    emitEntityDeleted(entityName: string, entity?: Entity): void;
+    /**
+     * Emit a relation:created event.
+     *
+     * @param relation - The relation that was created
+     */
+    emitRelationCreated(relation: Relation): void;
+    /**
+     * Emit a relation:deleted event.
+     *
+     * @param from - Source entity name
+     * @param to - Target entity name
+     * @param relationType - Type of the deleted relation
+     */
+    emitRelationDeleted(from: string, to: string, relationType: string): void;
+    /**
+     * Emit an observation:added event.
+     *
+     * @param entityName - Name of the entity
+     * @param observations - Observations that were added
+     */
+    emitObservationAdded(entityName: string, observations: string[]): void;
+    /**
+     * Emit an observation:deleted event.
+     *
+     * @param entityName - Name of the entity
+     * @param observations - Observations that were deleted
+     */
+    emitObservationDeleted(entityName: string, observations: string[]): void;
+    /**
+     * Emit a graph:saved event.
+     *
+     * @param entityCount - Number of entities in the saved graph
+     * @param relationCount - Number of relations in the saved graph
+     */
+    emitGraphSaved(entityCount: number, relationCount: number): void;
+    /**
+     * Emit a graph:loaded event.
+     *
+     * @param entityCount - Number of entities in the loaded graph
+     * @param relationCount - Number of relations in the loaded graph
+     */
+    emitGraphLoaded(entityCount: number, relationCount: number): void;
+    /**
+     * Safely invoke a listener, optionally catching errors.
+     * @private
+     */
+    private invokeListener;
+}
+//# sourceMappingURL=GraphEventEmitter.d.ts.map

package/dist/core/GraphEventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphEventEmitter.d.ts","sourceRoot":"","sources":["../../src/core/GraphEventEmitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,UAAU,EACV,kBAAkB,EAClB,aAAa,EACb,MAAM,EACN,QAAQ,EAUT,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,iBAAiB;IAC5B;;OAEG;IACH,OAAO,CAAC,SAAS,CAAgE;IAEjF;;OAEG;IACH,OAAO,CAAC,iBAAiB,CAAkD;IAE3E;;;OAGG;IACH,OAAO,CAAC,sBAAsB,CAAiB;IAE/C;;;;OAIG;gBACS,OAAO,CAAC,EAAE;QAAE,sBAAsB,CAAC,EAAE,OAAO,CAAA;KAAE;IAQ1D;;;;;;;;;;;;;;;;OAgBG;IACH,EAAE,CAAC,CAAC,SAAS,cAAc,EACzB,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,kBAAkB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAC7C,MAAM,IAAI;IAYb;;;;;;OAMG;IACH,GAAG,CAAC,CAAC,SAAS,cAAc,EAC1B,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,kBAAkB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAC7C,IAAI;IAOP;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,QAAQ,EAAE,kBAAkB,CAAC,UAAU,CAAC,GAAG,MAAM,IAAI;IAO3D;;;;OAIG;IACH,MAAM,CAAC,QAAQ,EAAE,kBAAkB,CAAC,UAAU,CAAC,GAAG,IAAI;IAItD;;;;;;;OAOG;IACH,IAAI,CAAC,CAAC,SAAS,cAAc,EAC3B,SAAS,EAAE,CAAC,EACZ,QAAQ,EAAE,kBAAkB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAC7C,MAAM,IAAI;IASb;;OAEG;IACH,kBAAkB,IAAI,IAAI;IAK1B;;;;;OAKG;IACH,aAAa,CAAC,SAAS,CAAC,EAAE,cAAc,GAAG,MAAM;IAcjD;;;;OAIG;IACH,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAe7B;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IASvC;;;;;;OAMG;IACH,iBAAiB,CACf,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,EACxB,cAAc,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,GAC/B,IAAI;IAWP;;;;;OAKG;IACH,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAU5D;;;;OAIG;IACH,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAS7C;;;;;;OAMG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAWzE;;;;;OAKG;IACH,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,IAAI;IAYtE;;;;;OAKG;IACH,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,IAAI;IAYxE;;;;;OAKG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAUhE;;;;;OAKG;IACH,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAYjE;;;OAGG;IACH,OAAO,CAAC,cAAc;CAYvB"}