@danielsimonjr/memory-mcp 0.47.1 → 9.8.0

package/dist/search/QueryCostEstimator.js

@@ -0,0 +1,355 @@
+/**
+ * Query Cost Estimator
+ *
+ * Phase 10 Sprint 4: Estimates the cost of different search methods
+ * and recommends the optimal method based on query characteristics
+ * and graph size.
+ *
+ * @module search/QueryCostEstimator
+ */
+/**
+ * Default options for the QueryCostEstimator.
+ */
+const DEFAULT_OPTIONS = {
+    basicTimePerEntity: 0.01,
+    rankedTimePerEntity: 0.05,
+    booleanTimePerEntity: 0.02,
+    fuzzyTimePerEntity: 0.1,
+    semanticTimePerEntity: 0.5,
+    lowComplexityThreshold: 100,
+    highComplexityThreshold: 1000,
+};
+/**
+ * Phase 10 Sprint 4: Estimates search query costs and recommends optimal methods.
+ *
+ * Analyzes query characteristics and graph size to estimate execution time
+ * and recommend the most appropriate search method.
+ *
+ * @example
+ * ```typescript
+ * const estimator = new QueryCostEstimator();
+ *
+ * // Get estimate for a specific method
+ * const estimate = estimator.estimateMethod('ranked', 'test query', 1000);
+ *
+ * // Get the recommended method for a query
+ * const recommendation = estimator.recommendMethod('test query', 1000);
+ *
+ * // Get estimates for all methods
+ * const allEstimates = estimator.estimateAllMethods('test query', 1000);
+ * ```
+ */
+export class QueryCostEstimator {
+    options;
+    /**
+     * Create a new QueryCostEstimator instance.
+     *
+     * @param options - Optional configuration overrides
+     */
+    constructor(options) {
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    /**
+     * Estimate the cost of a specific search method.
+     *
+     * @param method - The search method to estimate
+     * @param query - The search query
+     * @param entityCount - Number of entities in the graph
+     * @returns Cost estimate for the method
+     */
+    estimateMethod(method, query, entityCount) {
+        // Get the recommended method first to determine isRecommended
+        const recommendedMethod = this.getRecommendedMethodOnly(query, entityCount);
+        return this.estimateMethodInternal(method, query, entityCount, method === recommendedMethod);
+    }
+    /**
+     * Internal method to estimate without triggering recursion.
+     * @private
+     */
+    estimateMethodInternal(method, query, entityCount, isRecommended) {
+        const baseTime = this.getBaseTimeForMethod(method);
+        const queryComplexityFactor = this.getQueryComplexityFactor(query, method);
+        const estimatedTimeMs = baseTime * entityCount * queryComplexityFactor;
+        const complexity = this.getComplexity(entityCount);
+        const recommendation = this.getRecommendation(method, query, entityCount, complexity);
+        return {
+            method,
+            estimatedTimeMs: Math.round(estimatedTimeMs * 100) / 100,
+            complexity,
+            entityCount,
+            recommendation,
+            isRecommended,
+        };
+    }
+    /**
+     * Get just the recommended method without full estimate (avoids recursion).
+     * @private
+     */
+    getRecommendedMethodOnly(query, entityCount, preferredMethods) {
+        const methods = preferredMethods ?? ['basic', 'ranked', 'boolean', 'fuzzy', 'semantic'];
+        // Score each method and find the best
+        let bestMethod = methods[0];
+        let bestScore = this.scoreMethod(methods[0], query, entityCount);
+        for (let i = 1; i < methods.length; i++) {
+            const score = this.scoreMethod(methods[i], query, entityCount);
+            if (score > bestScore) {
+                bestScore = score;
+                bestMethod = methods[i];
+            }
+        }
+        return bestMethod;
+    }
+    /**
+     * Get estimates for all available search methods.
+     *
+     * @param query - The search query
+     * @param entityCount - Number of entities in the graph
+     * @returns Array of estimates for all methods
+     */
+    estimateAllMethods(query, entityCount) {
+        const methods = ['basic', 'ranked', 'boolean', 'fuzzy', 'semantic'];
+        const recommendedMethod = this.getRecommendedMethodOnly(query, entityCount);
+        return methods.map(method => this.estimateMethodInternal(method, query, entityCount, method === recommendedMethod));
+    }
+    /**
+     * Recommend the best search method for a query.
+     *
+     * @param query - The search query
+     * @param entityCount - Number of entities in the graph
+     * @param preferredMethods - Optional array of methods to consider (default: all)
+     * @returns The recommended method and reason
+     */
+    recommendMethod(query, entityCount, preferredMethods) {
+        const methods = preferredMethods ?? ['basic', 'ranked', 'boolean', 'fuzzy', 'semantic'];
+        // Score each method based on query characteristics and cost
+        const scores = methods.map(method => ({
+            method,
+            score: this.scoreMethod(method, query, entityCount),
+            estimate: this.estimateMethod(method, query, entityCount),
+        }));
+        // Sort by score (higher is better)
+        scores.sort((a, b) => b.score - a.score);
+        const best = scores[0];
+        const reason = this.getSelectionReason(best.method, query, entityCount);
+        return {
+            method: best.method,
+            reason,
+            estimate: best.estimate,
+        };
+    }
+    /**
+     * Get the base time per entity for a search method.
+     * @private
+     */
+    getBaseTimeForMethod(method) {
+        switch (method) {
+            case 'basic':
+                return this.options.basicTimePerEntity;
+            case 'ranked':
+                return this.options.rankedTimePerEntity;
+            case 'boolean':
+                return this.options.booleanTimePerEntity;
+            case 'fuzzy':
+                return this.options.fuzzyTimePerEntity;
+            case 'semantic':
+                return this.options.semanticTimePerEntity;
+        }
+    }
+    /**
+     * Calculate a complexity factor based on query characteristics.
+     * @private
+     */
+    getQueryComplexityFactor(query, method) {
+        const words = query.trim().split(/\s+/).length;
+        const hasOperators = /\b(AND|OR|NOT)\b/.test(query);
+        const hasWildcard = query.includes('*');
+        const hasQuotes = query.includes('"');
+        let factor = 1.0;
+        // More words = slightly more complex
+        factor += (words - 1) * 0.1;
+        // Boolean operators increase boolean search cost, decrease others
+        if (hasOperators) {
+            if (method === 'boolean') {
+                factor *= 0.8; // Boolean search is optimized for operators
+            }
+            else {
+                factor *= 1.5; // Other methods struggle with operators
+            }
+        }
+        // Wildcards increase fuzzy search efficiency
+        if (hasWildcard) {
+            if (method === 'fuzzy') {
+                factor *= 0.9;
+            }
+            else {
+                factor *= 1.3;
+            }
+        }
+        // Quoted phrases benefit ranked search
+        if (hasQuotes) {
+            if (method === 'ranked') {
+                factor *= 0.9;
+            }
+            else {
+                factor *= 1.1;
+            }
+        }
+        return Math.max(0.5, Math.min(factor, 3.0)); // Clamp between 0.5 and 3.0
+    }
+    /**
+     * Get the complexity level based on entity count.
+     * @private
+     */
+    getComplexity(entityCount) {
+        if (entityCount <= this.options.lowComplexityThreshold) {
+            return 'low';
+        }
+        if (entityCount >= this.options.highComplexityThreshold) {
+            return 'high';
+        }
+        return 'medium';
+    }
+    /**
+     * Generate a human-readable recommendation.
+     * @private
+     */
+    getRecommendation(method, _query, _entityCount, complexity) {
+        const recommendations = {
+            basic: 'Fast substring matching, best for simple queries',
+            ranked: 'TF-IDF relevance ranking, best for finding most relevant results',
+            boolean: 'Boolean operators (AND/OR/NOT), best for precise filtering',
+            fuzzy: 'Tolerant of typos and misspellings, best for uncertain queries',
+            semantic: 'Meaning-based search using embeddings, best for conceptual queries',
+        };
+        let recommendation = recommendations[method];
+        if (complexity === 'high' && method === 'semantic') {
+            recommendation += ' - may be slow for large graphs';
+        }
+        if (complexity === 'low') {
+            recommendation += ' - fast for small graphs';
+        }
+        return recommendation;
+    }
+    /**
+     * Score a method based on query characteristics and graph size.
+     * Higher score = better fit.
+     * @private
+     */
+    scoreMethod(method, query, entityCount) {
+        let score = 50; // Base score
+        const hasOperators = /\b(AND|OR|NOT)\b/.test(query);
+        const hasWildcard = query.includes('*');
+        const hasQuotes = query.includes('"');
+        const words = query.trim().split(/\s+/).length;
+        const isShortQuery = words <= 2;
+        const isLongQuery = words >= 5;
+        const complexity = this.getComplexity(entityCount);
+        switch (method) {
+            case 'basic':
+                // Basic is good for simple, short queries on any size graph
+                if (isShortQuery && !hasOperators && !hasWildcard) {
+                    score += 30;
+                }
+                if (complexity === 'low') {
+                    score += 20;
+                }
+                // Basic is fastest, give bonus for speed
+                score += 10;
+                break;
+            case 'ranked':
+                // Ranked is good for relevance-focused queries
+                if (words >= 2) {
+                    score += 25; // Better for multi-word queries
+                }
+                if (hasQuotes) {
+                    score += 15; // Good for phrase matching
+                }
+                if (!hasOperators) {
+                    score += 10; // Not optimized for boolean
+                }
+                // Good balance of speed and quality
+                score += 15;
+                break;
+            case 'boolean':
+                // Boolean is best for queries with operators
+                if (hasOperators) {
+                    score += 40;
+                }
+                if (!hasOperators) {
+                    score -= 20; // Not useful without operators
+                }
+                // Fast for filtering
+                score += 10;
+                break;
+            case 'fuzzy':
+                // Fuzzy is good for typo-tolerant search
+                if (hasWildcard) {
+                    score += 25;
+                }
+                if (isShortQuery) {
+                    score += 15; // Works best on shorter queries
+                }
+                if (isLongQuery) {
+                    score -= 15; // Slow on long queries
+                }
+                if (complexity === 'high') {
+                    score -= 20; // Slow on large graphs
+                }
+                break;
+            case 'semantic':
+                // Semantic is good for conceptual/meaning-based queries
+                if (isLongQuery) {
+                    score += 30; // Better for longer, more descriptive queries
+                }
+                if (!hasOperators && !hasWildcard) {
+                    score += 15; // Natural language queries
+                }
+                // Penalize for large graphs (slow)
+                if (complexity === 'high') {
+                    score -= 30;
+                }
+                if (complexity === 'medium') {
+                    score -= 10;
+                }
+                break;
+        }
+        return score;
+    }
+    /**
+     * Get a human-readable reason for why a method was selected.
+     * @private
+     */
+    getSelectionReason(method, query, entityCount) {
+        const hasOperators = /\b(AND|OR|NOT)\b/.test(query);
+        const hasWildcard = query.includes('*');
+        const words = query.trim().split(/\s+/).length;
+        const complexity = this.getComplexity(entityCount);
+        switch (method) {
+            case 'basic':
+                if (complexity === 'low') {
+                    return 'Basic search selected for small graph size - fast and efficient';
+                }
+                return 'Basic search selected for simple query pattern';
+            case 'ranked':
+                if (words >= 2) {
+                    return 'Ranked search selected for multi-word query - provides relevance ordering';
+                }
+                return 'Ranked search selected for best balance of speed and relevance';
+            case 'boolean':
+                if (hasOperators) {
+                    return 'Boolean search selected - query contains logical operators (AND/OR/NOT)';
+                }
+                return 'Boolean search selected for precise filtering';
+            case 'fuzzy':
+                if (hasWildcard) {
+                    return 'Fuzzy search selected - query contains wildcard patterns';
+                }
+                return 'Fuzzy search selected for typo-tolerant matching';
+            case 'semantic':
+                if (words >= 5) {
+                    return 'Semantic search selected - longer natural language query benefits from meaning-based matching';
+                }
+                return 'Semantic search selected for conceptual/meaning-based matching';
+        }
+    }
+}

package/dist/search/RankedSearch.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Ranked Search
+ *
+ * TF-IDF relevance-based search with scoring and pre-calculated indexes.
+ *
+ * @module search/RankedSearch
+ */
+import type { SearchResult } from '../types/index.js';
+import type { GraphStorage } from '../core/GraphStorage.js';
+/**
+ * Performs TF-IDF ranked search with optional pre-calculated indexes.
+ */
+export declare class RankedSearch {
+    private storage;
+    private indexManager;
+    /**
+     * Phase 4 Sprint 2: Fallback token cache for entities.
+     * Maps entity name -> pre-tokenized entity data.
+     * Invalidated when graph changes (detected by entity count mismatch).
+     */
+    private fallbackTokenCache;
+    private cachedEntityCount;
+    constructor(storage: GraphStorage, storageDir?: string);
+    /**
+     * Phase 4 Sprint 2: Clear the fallback token cache.
+     * Called when graph changes are detected or explicitly by external code.
+     */
+    clearTokenCache(): void;
+    /**
+     * Initialize and build the TF-IDF index for fast searches.
+     *
+     * Should be called after graph changes to keep index up-to-date.
+     */
+    buildIndex(): Promise<void>;
+    /**
+     * Update the index incrementally after entity changes.
+     *
+     * @param changedEntityNames - Names of entities that were created, updated, or deleted
+     */
+    updateIndex(changedEntityNames: Set<string>): Promise<void>;
+    /**
+     * Load the TF-IDF index from disk if available.
+     */
+    private ensureIndexLoaded;
+    /**
+     * Search with TF-IDF relevance ranking.
+     *
+     * Uses pre-calculated index if available, falls back to on-the-fly calculation.
+     *
+     * @param query - Search query
+     * @param tags - Optional tags filter
+     * @param minImportance - Optional minimum importance
+     * @param maxImportance - Optional maximum importance
+     * @param limit - Maximum results to return (default 50, max 200)
+     * @returns Array of search results sorted by relevance
+     */
+    searchNodesRanked(query: string, tags?: string[], minImportance?: number, maxImportance?: number, limit?: number): Promise<SearchResult[]>;
+    /**
+     * Search using pre-calculated TF-IDF index (fast path).
+     */
+    private searchWithIndex;
+    /**
+     * Search without index (on-the-fly calculation, slow path).
+     *
+     * OPTIMIZED: Phase 4 Sprint 2 - Uses fallback token cache to avoid
+     * repeated tokenization of entities. Pre-tokenizes all documents once
+     * and caches for subsequent searches.
+     */
+    private searchWithoutIndex;
+}
+//# sourceMappingURL=RankedSearch.d.ts.map

package/dist/search/RankedSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RankedSearch.d.ts","sourceRoot":"","sources":["../../src/search/RankedSearch.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAU,YAAY,EAA+B,MAAM,mBAAmB,CAAC;AAC3F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAM5D;;GAEG;AACH,qBAAa,YAAY;IAYrB,OAAO,CAAC,OAAO;IAXjB,OAAO,CAAC,YAAY,CAAkC;IAEtD;;;;OAIG;IACH,OAAO,CAAC,kBAAkB,CAA2C;IACrE,OAAO,CAAC,iBAAiB,CAAa;gBAG5B,OAAO,EAAE,YAAY,EAC7B,UAAU,CAAC,EAAE,MAAM;IAQrB;;;OAGG;IACH,eAAe,IAAI,IAAI;IAKvB;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAUjC;;;;OAIG;IACG,WAAW,CAAC,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAUjE;;OAEG;YACW,iBAAiB;IAe/B;;;;;;;;;;;OAWG;IACG,iBAAiB,CACrB,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,aAAa,CAAC,EAAE,MAAM,EACtB,aAAa,CAAC,EAAE,MAAM,EACtB,KAAK,GAAE,MAA8B,GACpC,OAAO,CAAC,YAAY,EAAE,CAAC;IAsB1B;;OAEG;IACH,OAAO,CAAC,eAAe;IAgEvB;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;CAqF3B"}

package/dist/search/RankedSearch.js

@@ -5,7 +5,7 @@
  *
  * @module search/RankedSearch
  */
-import { calculateTFIDF, tokenize } from '../utils/tfidf.js';
+import { calculateTF, calculateIDFFromTokenSets, tokenize } from '../utils/index.js';
 import { SEARCH_LIMITS } from '../utils/constants.js';
 import { TFIDFIndexManager } from './TFIDFIndexManager.js';
 import { SearchFilterChain } from './SearchFilterChain.js';
@@ -15,6 +15,13 @@ import { SearchFilterChain } from './SearchFilterChain.js';
 export class RankedSearch {
     storage;
     indexManager = null;
+    /**
+     * Phase 4 Sprint 2: Fallback token cache for entities.
+     * Maps entity name -> pre-tokenized entity data.
+     * Invalidated when graph changes (detected by entity count mismatch).
+     */
+    fallbackTokenCache = new Map();
+    cachedEntityCount = 0;
     constructor(storage, storageDir) {
         this.storage = storage;
         // Initialize index manager if storage directory is provided
@@ -22,6 +29,14 @@ export class RankedSearch {
             this.indexManager = new TFIDFIndexManager(storageDir);
         }
     }
+    /**
+     * Phase 4 Sprint 2: Clear the fallback token cache.
+     * Called when graph changes are detected or explicitly by external code.
+     */
+    clearTokenCache() {
+        this.fallbackTokenCache.clear();
+        this.cachedEntityCount = 0;
+    }
     /**
      * Initialize and build the TF-IDF index for fast searches.
      *
@@ -148,18 +163,51 @@ export class RankedSearch {
     }
     /**
      * Search without index (on-the-fly calculation, slow path).
+     *
+     * OPTIMIZED: Phase 4 Sprint 2 - Uses fallback token cache to avoid
+     * repeated tokenization of entities. Pre-tokenizes all documents once
+     * and caches for subsequent searches.
      */
     searchWithoutIndex(entities, queryTerms, limit) {
         const results = [];
-        const documents = entities.map(e => [e.name, e.entityType, ...e.observations].join(' '));
-        for (let i = 0; i < entities.length; i++) {
-            const entity = entities[i];
-            const document = documents[i];
+        // Phase 4 Sprint 2: Check if cache needs invalidation
+        if (entities.length !== this.cachedEntityCount) {
+            this.clearTokenCache();
+            this.cachedEntityCount = entities.length;
+        }
+        // Phase 4 Sprint 2: Get or compute tokenized data for each entity
+        const documentData = entities.map(e => {
+            // Check cache first
+            const cached = this.fallbackTokenCache.get(e.name);
+            if (cached) {
+                return cached;
+            }
+            // Compute and cache tokenized data
+            const text = [e.name, e.entityType, ...e.observations].join(' ');
+            const tokens = tokenize(text);
+            const tokenized = {
+                entity: e,
+                text,
+                tokens,
+                tokenSet: new Set(tokens),
+            };
+            this.fallbackTokenCache.set(e.name, tokenized);
+            return tokenized;
+        });
+        // Pre-compute token sets for IDF calculation (O(1) lookup per document)
+        const tokenSets = documentData.map(d => d.tokenSet);
+        for (const docData of documentData) {
+            const { entity, text } = docData;
             // Calculate score for each query term
             let totalScore = 0;
             const matchedFields = {};
             for (const term of queryTerms) {
-                const score = calculateTFIDF(term, document, documents);
+                // Calculate TF using pre-tokenized tokens
+                const tf = calculateTF(term, text);
+                // Calculate IDF using pre-computed token sets (O(1) per document)
+                const idf = calculateIDFFromTokenSets(term, tokenSets);
+                // TF-IDF score
+                const score = tf * idf;
                 totalScore += score;
                 // Track which fields matched
                 if (entity.name.toLowerCase().includes(term)) {

package/dist/search/SavedSearchManager.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Saved Search Manager
+ *
+ * Manages persistent saved searches with JSONL storage.
+ *
+ * @module search/SavedSearchManager
+ */
+import type { SavedSearch, KnowledgeGraph } from '../types/index.js';
+import type { BasicSearch } from './BasicSearch.js';
+/**
+ * Manages saved search queries with usage tracking.
+ */
+export declare class SavedSearchManager {
+    private savedSearchesFilePath;
+    private basicSearch;
+    constructor(savedSearchesFilePath: string, basicSearch: BasicSearch);
+    /**
+     * Load all saved searches from JSONL file.
+     *
+     * @returns Array of saved searches
+     */
+    private loadSavedSearches;
+    /**
+     * Save searches to JSONL file.
+     *
+     * @param searches - Array of saved searches
+     */
+    private saveSavedSearches;
+    /**
+     * Save a search query for later reuse.
+     *
+     * @param search - Search parameters (without createdAt, useCount, lastUsed)
+     * @returns The newly created saved search
+     * @throws Error if search name already exists
+     */
+    saveSearch(search: Omit<SavedSearch, 'createdAt' | 'useCount' | 'lastUsed'>): Promise<SavedSearch>;
+    /**
+     * List all saved searches.
+     *
+     * @returns Array of all saved searches
+     */
+    listSavedSearches(): Promise<SavedSearch[]>;
+    /**
+     * Get a specific saved search by name.
+     *
+     * @param name - Search name
+     * @returns Saved search or null if not found
+     */
+    getSavedSearch(name: string): Promise<SavedSearch | null>;
+    /**
+     * Execute a saved search by name.
+     *
+     * Updates usage statistics (lastUsed, useCount) before executing.
+     *
+     * @param name - Search name
+     * @returns Search results as knowledge graph
+     * @throws Error if search not found
+     */
+    executeSavedSearch(name: string): Promise<KnowledgeGraph>;
+    /**
+     * Delete a saved search.
+     *
+     * @param name - Search name
+     * @returns True if deleted, false if not found
+     */
+    deleteSavedSearch(name: string): Promise<boolean>;
+    /**
+     * Update a saved search.
+     *
+     * Cannot update name, createdAt, useCount, or lastUsed fields.
+     *
+     * @param name - Search name
+     * @param updates - Partial search with fields to update
+     * @returns Updated saved search
+     * @throws Error if search not found
+     */
+    updateSavedSearch(name: string, updates: Partial<Omit<SavedSearch, 'name' | 'createdAt' | 'useCount' | 'lastUsed'>>): Promise<SavedSearch>;
+}
+//# sourceMappingURL=SavedSearchManager.d.ts.map

package/dist/search/SavedSearchManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SavedSearchManager.d.ts","sourceRoot":"","sources":["../../src/search/SavedSearchManager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD;;GAEG;AACH,qBAAa,kBAAkB;IAE3B,OAAO,CAAC,qBAAqB;IAC7B,OAAO,CAAC,WAAW;gBADX,qBAAqB,EAAE,MAAM,EAC7B,WAAW,EAAE,WAAW;IAGlC;;;;OAIG;YACW,iBAAiB;IAa/B;;;;OAIG;YACW,iBAAiB;IAK/B;;;;;;OAMG;IACG,UAAU,CACd,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC,GAC/D,OAAO,CAAC,WAAW,CAAC;IAoBvB;;;;OAIG;IACG,iBAAiB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAIjD;;;;;OAKG;IACG,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAK/D;;;;;;;;OAQG;IACG,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAsB/D;;;;;OAKG;IACG,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAavD;;;;;;;;;OASG;IACG,iBAAiB,CACrB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,CAAC,CAAC,GAClF,OAAO,CAAC,WAAW,CAAC;CAcxB"}