@danielsimonjr/memory-mcp 12.2.3 → 12.5.2

package/dist/search/BooleanSearch.js

@@ -1,430 +0,0 @@
-/**
- * Boolean Search
- *
- * Advanced search with boolean operators (AND, OR, NOT) and field-specific queries.
- *
- * @module search/BooleanSearch
- */
-import { SEARCH_LIMITS, QUERY_LIMITS } from '../utils/constants.js';
-import { ValidationError } from '../utils/errors.js';
-import { SearchFilterChain } from './SearchFilterChain.js';
-/**
- * Phase 4 Sprint 4: Maximum AST cache size.
- */
-const AST_CACHE_MAX_SIZE = 50;
-/**
- * Phase 4 Sprint 4: Result cache max size.
- */
-const RESULT_CACHE_MAX_SIZE = 100;
-/**
- * Phase 4 Sprint 4: Cache TTL in milliseconds (5 minutes).
- */
-const BOOLEAN_CACHE_TTL_MS = 5 * 60 * 1000;
-/**
- * Performs boolean search with query parsing and AST evaluation.
- */
-export class BooleanSearch {
-    storage;
-    /**
-     * Phase 4 Sprint 4: AST cache to avoid re-parsing queries.
-     * Maps query string -> parsed AST.
-     */
-    astCache = new Map();
-    /**
-     * Phase 4 Sprint 4: Result cache for boolean search.
-     * Maps cache key -> cached results.
-     */
-    resultCache = new Map();
-    constructor(storage) {
-        this.storage = storage;
-    }
-    /**
-     * Phase 4 Sprint 4: Generate cache key for boolean search.
-     */
-    generateCacheKey(query, tags, minImportance, maxImportance, offset, limit) {
-        return JSON.stringify({
-            q: query,
-            tags: tags?.sort().join(',') ?? '',
-            min: minImportance,
-            max: maxImportance,
-            off: offset,
-            lim: limit,
-        });
-    }
-    /**
-     * Phase 4 Sprint 4: Clear all caches.
-     */
-    clearCache() {
-        this.astCache.clear();
-        this.resultCache.clear();
-    }
-    /**
-     * Phase 4 Sprint 4: Cleanup old cache entries.
-     */
-    cleanupResultCache() {
-        const now = Date.now();
-        const entries = Array.from(this.resultCache.entries());
-        // Remove expired entries
-        for (const [key, entry] of entries) {
-            if (now - entry.timestamp > BOOLEAN_CACHE_TTL_MS) {
-                this.resultCache.delete(key);
-            }
-        }
-        // If still over limit, remove oldest entries
-        if (this.resultCache.size > RESULT_CACHE_MAX_SIZE) {
-            const sortedEntries = entries
-                .filter(([k]) => this.resultCache.has(k))
-                .sort((a, b) => a[1].timestamp - b[1].timestamp);
-            const toRemove = sortedEntries.slice(0, this.resultCache.size - RESULT_CACHE_MAX_SIZE);
-            for (const [key] of toRemove) {
-                this.resultCache.delete(key);
-            }
-        }
-    }
-    /**
-     * Phase 4 Sprint 4: Get or parse AST for a query.
-     */
-    getOrParseAST(query) {
-        // Check AST cache
-        const cached = this.astCache.get(query);
-        if (cached) {
-            return cached;
-        }
-        // Parse and cache
-        const ast = this.parseBooleanQuery(query);
-        // Enforce cache size limit
-        if (this.astCache.size >= AST_CACHE_MAX_SIZE) {
-            // Remove first entry (oldest)
-            const firstKey = this.astCache.keys().next().value;
-            if (firstKey)
-                this.astCache.delete(firstKey);
-        }
-        this.astCache.set(query, ast);
-        return ast;
-    }
-    /**
-     * Boolean search with support for AND, OR, NOT operators, field-specific queries, and pagination.
-     *
-     * Phase 4 Sprint 4: Implements AST caching and result caching for repeated queries.
-     *
-     * Query syntax examples:
-     * - "alice AND programming" - Both terms must match
-     * - "type:person OR type:organization" - Either type matches
-     * - "NOT archived" - Exclude archived items
-     * - "name:alice AND (observation:coding OR observation:teaching)"
-     *
-     * @param query - Boolean query string
-     * @param tags - Optional tags filter
-     * @param minImportance - Optional minimum importance
-     * @param maxImportance - Optional maximum importance
-     * @param offset - Number of results to skip (default: 0)
-     * @param limit - Maximum number of results (default: 50, max: 200)
-     * @returns Filtered knowledge graph matching the boolean query with pagination applied
-     */
-    async booleanSearch(query, tags, minImportance, maxImportance, offset = 0, limit = SEARCH_LIMITS.DEFAULT) {
-        // Validate query length
-        if (query.length > QUERY_LIMITS.MAX_QUERY_LENGTH) {
-            throw new ValidationError('Query too long', [`Query length ${query.length} exceeds maximum of ${QUERY_LIMITS.MAX_QUERY_LENGTH} characters`]);
-        }
-        const graph = await this.storage.loadGraph();
-        // Phase 4 Sprint 4: Check result cache
-        const cacheKey = this.generateCacheKey(query, tags, minImportance, maxImportance, offset, limit);
-        const cached = this.resultCache.get(cacheKey);
-        if (cached && cached.entityCount === graph.entities.length) {
-            const now = Date.now();
-            if (now - cached.timestamp < BOOLEAN_CACHE_TTL_MS) {
-                // Return cached results
-                const cachedNameSet = new Set(cached.entityNames);
-                const cachedEntities = graph.entities.filter(e => cachedNameSet.has(e.name));
-                const cachedRelations = graph.relations.filter(r => cachedNameSet.has(r.from) && cachedNameSet.has(r.to));
-                return { entities: cachedEntities, relations: cachedRelations };
-            }
-        }
-        // Phase 4 Sprint 4: Use cached AST or parse new one
-        let queryAst;
-        try {
-            queryAst = this.getOrParseAST(query);
-        }
-        catch (error) {
-            throw new Error(`Failed to parse boolean query: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        // Validate query complexity
-        this.validateQueryComplexity(queryAst);
-        // First filter by boolean query evaluation (search-specific)
-        const booleanMatched = graph.entities.filter(e => this.evaluateBooleanQuery(queryAst, e));
-        // Apply tag and importance filters using SearchFilterChain
-        const filters = { tags, minImportance, maxImportance };
-        const filteredEntities = SearchFilterChain.applyFilters(booleanMatched, filters);
-        // Apply pagination using SearchFilterChain
-        const pagination = SearchFilterChain.validatePagination(offset, limit);
-        const paginatedEntities = SearchFilterChain.paginate(filteredEntities, pagination);
-        // Phase 4 Sprint 4: Cache the results
-        this.resultCache.set(cacheKey, {
-            ast: queryAst,
-            entityNames: paginatedEntities.map(e => e.name),
-            entityCount: graph.entities.length,
-            timestamp: Date.now(),
-        });
-        // Cleanup old cache entries periodically
-        if (this.resultCache.size > RESULT_CACHE_MAX_SIZE / 2) {
-            this.cleanupResultCache();
-        }
-        const filteredEntityNames = new Set(paginatedEntities.map(e => e.name));
-        const filteredRelations = graph.relations.filter(r => filteredEntityNames.has(r.from) && filteredEntityNames.has(r.to));
-        return { entities: paginatedEntities, relations: filteredRelations };
-    }
-    /**
-     * Tokenize a boolean query into tokens.
-     *
-     * Handles quoted strings, parentheses, and operators.
-     */
-    tokenizeBooleanQuery(query) {
-        const tokens = [];
-        let current = '';
-        let inQuotes = false;
-        for (let i = 0; i < query.length; i++) {
-            const char = query[i];
-            if (char === '"') {
-                if (inQuotes) {
-                    // End of quoted string
-                    tokens.push(current);
-                    current = '';
-                    inQuotes = false;
-                }
-                else {
-                    // Start of quoted string
-                    if (current.trim()) {
-                        tokens.push(current.trim());
-                        current = '';
-                    }
-                    inQuotes = true;
-                }
-            }
-            else if (!inQuotes && (char === '(' || char === ')')) {
-                // Parentheses are separate tokens
-                if (current.trim()) {
-                    tokens.push(current.trim());
-                    current = '';
-                }
-                tokens.push(char);
-            }
-            else if (!inQuotes && /\s/.test(char)) {
-                // Whitespace outside quotes
-                if (current.trim()) {
-                    tokens.push(current.trim());
-                    current = '';
-                }
-            }
-            else {
-                current += char;
-            }
-        }
-        if (current.trim()) {
-            tokens.push(current.trim());
-        }
-        return tokens;
-    }
-    /**
-     * Parse a boolean search query into an AST.
-     *
-     * Supports: AND, OR, NOT, parentheses, field-specific queries (field:value)
-     */
-    parseBooleanQuery(query) {
-        const tokens = this.tokenizeBooleanQuery(query);
-        let position = 0;
-        const peek = () => tokens[position];
-        const consume = () => tokens[position++];
-        // Parse OR expressions (lowest precedence)
-        const parseOr = () => {
-            let left = parseAnd();
-            while (peek()?.toUpperCase() === 'OR') {
-                consume(); // consume 'OR'
-                const right = parseAnd();
-                left = { type: 'OR', children: [left, right] };
-            }
-            return left;
-        };
-        // Parse AND expressions
-        const parseAnd = () => {
-            let left = parseNot();
-            while (peek() && peek()?.toUpperCase() !== 'OR' && peek() !== ')') {
-                // Implicit AND if next token is not OR or )
-                if (peek()?.toUpperCase() === 'AND') {
-                    consume(); // consume 'AND'
-                }
-                const right = parseNot();
-                left = { type: 'AND', children: [left, right] };
-            }
-            return left;
-        };
-        // Parse NOT expressions
-        const parseNot = () => {
-            if (peek()?.toUpperCase() === 'NOT') {
-                consume(); // consume 'NOT'
-                const child = parseNot();
-                return { type: 'NOT', child };
-            }
-            return parsePrimary();
-        };
-        // Parse primary expressions (terms, field queries, parentheses)
-        const parsePrimary = () => {
-            const token = peek();
-            if (!token) {
-                throw new Error('Unexpected end of query');
-            }
-            // Parentheses
-            if (token === '(') {
-                consume(); // consume '('
-                const node = parseOr();
-                if (consume() !== ')') {
-                    throw new Error('Expected closing parenthesis');
-                }
-                return node;
-            }
-            // Field-specific query (field:value)
-            if (token.includes(':')) {
-                consume();
-                const [field, ...valueParts] = token.split(':');
-                const value = valueParts.join(':'); // Handle colons in value
-                return { type: 'TERM', field: field.toLowerCase(), value: value.toLowerCase() };
-            }
-            // Regular term
-            consume();
-            return { type: 'TERM', value: token.toLowerCase() };
-        };
-        const result = parseOr();
-        // Check for unconsumed tokens
-        if (position < tokens.length) {
-            throw new Error(`Unexpected token: ${tokens[position]}`);
-        }
-        return result;
-    }
-    /**
-     * Evaluate a boolean query AST against an entity.
-     */
-    evaluateBooleanQuery(node, entity) {
-        switch (node.type) {
-            case 'AND':
-                return node.children.every(child => this.evaluateBooleanQuery(child, entity));
-            case 'OR':
-                return node.children.some(child => this.evaluateBooleanQuery(child, entity));
-            case 'NOT':
-                return !this.evaluateBooleanQuery(node.child, entity);
-            case 'TERM': {
-                const value = node.value;
-                // OPTIMIZED: Use pre-computed lowercase cache
-                const lowercased = this.storage.getLowercased(entity.name);
-                // Field-specific search
-                if (node.field) {
-                    switch (node.field) {
-                        case 'name':
-                            return lowercased ? lowercased.name.includes(value) : entity.name.toLowerCase().includes(value);
-                        case 'type':
-                        case 'entitytype':
-                            return lowercased ? lowercased.entityType.includes(value) : entity.entityType.toLowerCase().includes(value);
-                        case 'observation':
-                        case 'observations':
-                            // OPTIMIZED: Use observation index for simple single-word terms (O(1) vs O(n))
-                            // The index only matches complete words, not substrings, so we can only
-                            // use it as a quick positive check. If not found in index, fall through
-                            // to substring matching for compatibility.
-                            if (this.isSimpleTerm(value) && !value.includes(' ')) {
-                                const candidateNames = this.storage.getEntitiesByObservationWord(value);
-                                if (candidateNames.has(entity.name)) {
-                                    return true; // O(1) positive match
-                                }
-                                // Not found in index - entity doesn't have this complete word,
-                                // but might contain it as substring - fall through to check
-                            }
-                            // Linear scan for substring matches, phrases, and patterns
-                            return lowercased
-                                ? lowercased.observations.some(obs => obs.includes(value))
-                                : entity.observations.some(obs => obs.toLowerCase().includes(value));
-                        case 'tag':
-                        case 'tags':
-                            return lowercased
-                                ? lowercased.tags.some(tag => tag.includes(value))
-                                : (entity.tags?.some(tag => tag.toLowerCase().includes(value)) || false);
-                        default:
-                            // Unknown field, search all text fields
-                            return this.entityMatchesTerm(entity, value, lowercased);
-                    }
-                }
-                // General search across all fields
-                return this.entityMatchesTerm(entity, value, lowercased);
-            }
-        }
-    }
-    /**
-     * Check if a search term is simple (no regex or wildcards).
-     * Simple terms can use the O(1) observation index.
-     */
-    isSimpleTerm(term) {
-        const specialChars = /[.*+?^${}()|\\[\]]/;
-        return !specialChars.test(term);
-    }
-    /**
-     * Check if entity matches a search term in any text field.
-     * OPTIMIZED: Uses pre-computed lowercase data when available.
-     */
-    entityMatchesTerm(entity, term, lowercased) {
-        if (lowercased) {
-            return (lowercased.name.includes(term) ||
-                lowercased.entityType.includes(term) ||
-                lowercased.observations.some(obs => obs.includes(term)) ||
-                lowercased.tags.some(tag => tag.includes(term)));
-        }
-        // Fallback for entities not in cache
-        const termLower = term.toLowerCase();
-        return (entity.name.toLowerCase().includes(termLower) ||
-            entity.entityType.toLowerCase().includes(termLower) ||
-            entity.observations.some(obs => obs.toLowerCase().includes(termLower)) ||
-            (entity.tags?.some(tag => tag.toLowerCase().includes(termLower)) || false));
-    }
-    /**
-     * Validate query complexity to prevent resource exhaustion.
-     * Checks nesting depth, term count, and operator count against configured limits.
-     */
-    validateQueryComplexity(node, depth = 0) {
-        // Check nesting depth
-        if (depth > QUERY_LIMITS.MAX_DEPTH) {
-            throw new ValidationError('Query too complex', [`Query nesting depth ${depth} exceeds maximum of ${QUERY_LIMITS.MAX_DEPTH}`]);
-        }
-        // Count terms and operators recursively
-        const complexity = this.calculateQueryComplexity(node);
-        if (complexity.terms > QUERY_LIMITS.MAX_TERMS) {
-            throw new ValidationError('Query too complex', [`Query has ${complexity.terms} terms, exceeds maximum of ${QUERY_LIMITS.MAX_TERMS}`]);
-        }
-        if (complexity.operators > QUERY_LIMITS.MAX_OPERATORS) {
-            throw new ValidationError('Query too complex', [`Query has ${complexity.operators} operators, exceeds maximum of ${QUERY_LIMITS.MAX_OPERATORS}`]);
-        }
-    }
-    /**
-     * Calculate query complexity metrics.
-     */
-    calculateQueryComplexity(node, depth = 0) {
-        switch (node.type) {
-            case 'AND':
-            case 'OR':
-                const childResults = node.children.map(child => this.calculateQueryComplexity(child, depth + 1));
-                return {
-                    terms: childResults.reduce((sum, r) => sum + r.terms, 0),
-                    operators: childResults.reduce((sum, r) => sum + r.operators, 1), // +1 for current operator
-                    maxDepth: Math.max(depth, ...childResults.map(r => r.maxDepth)),
-                };
-            case 'NOT':
-                const notResult = this.calculateQueryComplexity(node.child, depth + 1);
-                return {
-                    terms: notResult.terms,
-                    operators: notResult.operators + 1,
-                    maxDepth: Math.max(depth, notResult.maxDepth),
-                };
-            case 'TERM':
-                return {
-                    terms: 1,
-                    operators: 0,
-                    maxDepth: depth,
-                };
-        }
-    }
-}

package/dist/search/EmbeddingService.d.ts

@@ -1,178 +0,0 @@
-/**
- * Embedding Service
- *
- * Phase 4 Sprint 10: Provides embedding abstractions for semantic search.
- * Supports multiple providers: OpenAI (cloud) and local (transformers.js).
- *
- * @module search/EmbeddingService
- */
-import type { EmbeddingService, EmbeddingConfig } from '../types/index.js';
-/**
- * OpenAI Embedding Service
- *
- * Uses OpenAI's text-embedding-3-small model for generating embeddings.
- * Supports single and batch embedding with rate limit handling.
- *
- * @example
- * ```typescript
- * const service = new OpenAIEmbeddingService('sk-...');
- * const embedding = await service.embed("Hello world");
- * console.log(`Generated ${embedding.length} dimensions`);
- * ```
- */
-export declare class OpenAIEmbeddingService implements EmbeddingService {
-    readonly dimensions: number;
-    readonly provider = "openai";
-    readonly model: string;
-    private apiKey;
-    /**
-     * Create an OpenAI embedding service.
-     *
-     * @param apiKey - OpenAI API key
-     * @param model - Optional model override (default: text-embedding-3-small)
-     */
-    constructor(apiKey: string, model?: string);
-    /**
-     * Check if the service is ready.
-     */
-    isReady(): Promise<boolean>;
-    /**
-     * Generate embedding for a single text.
-     *
-     * @param text - Text to embed
-     * @returns Embedding vector
-     */
-    embed(text: string): Promise<number[]>;
-    /**
-     * Generate embeddings for multiple texts in batch.
-     *
-     * @param texts - Array of texts to embed
-     * @returns Array of embedding vectors
-     */
-    embedBatch(texts: string[]): Promise<number[][]>;
-    /**
-     * Internal batch embedding with retry logic.
-     */
-    private embedBatchInternal;
-    /**
-     * Check if an error is retryable.
-     */
-    private isRetryableError;
-    /**
-     * Sleep for a given duration.
-     */
-    private sleep;
-}
-/**
- * Local Embedding Service
- *
- * Uses @xenova/transformers for local embedding generation.
- * No API calls needed - runs entirely offline after initial model download.
- *
- * Note: Requires @xenova/transformers to be installed as an optional dependency.
- * If not available, initialization will fail gracefully.
- *
- * @example
- * ```typescript
- * const service = new LocalEmbeddingService();
- * await service.initialize();
- * const embedding = await service.embed("Hello world");
- * ```
- */
-export declare class LocalEmbeddingService implements EmbeddingService {
-    readonly dimensions: number;
-    readonly provider = "local";
-    readonly model: string;
-    private pipeline;
-    private initialized;
-    private initPromise;
-    /**
-     * Create a local embedding service.
-     *
-     * @param model - Optional model override (default: Xenova/all-MiniLM-L6-v2)
-     */
-    constructor(model?: string);
-    /**
-     * Initialize the model pipeline.
-     * Must be called before using embed/embedBatch.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Internal initialization.
-     */
-    private initializeInternal;
-    /**
-     * Check if the service is ready.
-     */
-    isReady(): Promise<boolean>;
-    /**
-     * Generate embedding for a single text.
-     *
-     * @param text - Text to embed
-     * @returns Embedding vector
-     */
-    embed(text: string): Promise<number[]>;
-    /**
-     * Generate embeddings for multiple texts in batch.
-     * Note: Local processing is done sequentially to avoid memory issues.
-     *
-     * @param texts - Array of texts to embed
-     * @returns Array of embedding vectors
-     */
-    embedBatch(texts: string[]): Promise<number[][]>;
-    /**
-     * Ensure the service is initialized.
-     */
-    private ensureInitialized;
-}
-/**
- * Mock Embedding Service for testing
- *
- * Generates deterministic mock embeddings for testing purposes.
- * Useful for unit tests that don't need real embeddings.
- */
-export declare class MockEmbeddingService implements EmbeddingService {
-    readonly dimensions: number;
-    readonly provider = "mock";
-    readonly model = "mock-model";
-    /**
-     * Create a mock embedding service.
-     *
-     * @param dimensions - Number of dimensions for mock embeddings
-     */
-    constructor(dimensions?: number);
-    /**
-     * Check if the service is ready.
-     */
-    isReady(): Promise<boolean>;
-    /**
-     * Generate a deterministic mock embedding for a text.
-     *
-     * @param text - Text to embed
-     * @returns Mock embedding vector
-     */
-    embed(text: string): Promise<number[]>;
-    /**
-     * Generate mock embeddings for multiple texts.
-     *
-     * @param texts - Array of texts to embed
-     * @returns Array of mock embedding vectors
-     */
-    embedBatch(texts: string[]): Promise<number[][]>;
-    /**
-     * Simple string hash function.
-     */
-    private hashString;
-    /**
-     * Normalize a vector to unit length.
-     */
-    private normalize;
-}
-/**
- * Create an embedding service based on configuration.
- *
- * @param config - Optional configuration override
- * @returns Embedding service instance, or null if provider is 'none'
- */
-export declare function createEmbeddingService(config?: Partial<EmbeddingConfig>): EmbeddingService | null;
-//# sourceMappingURL=EmbeddingService.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"EmbeddingService.d.ts","sourceRoot":"","sources":["../../src/search/EmbeddingService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAO3E;;;;;;;;;;;;GAYG;AACH,qBAAa,sBAAuB,YAAW,gBAAgB;IAC7D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,YAAY;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,MAAM,CAAS;IAEvB;;;;;OAKG;gBACS,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;IAS1C;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAIjC;;;;;OAKG;IACG,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAK5C;;;;;OAKG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IAkBtD;;OAEG;YACW,kBAAkB;IA0DhC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd;AAmBD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,qBAAsB,YAAW,gBAAgB;IAC5D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAuC;IAClE,QAAQ,CAAC,QAAQ,WAAW;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,WAAW,CAA8B;IAEjD;;;;OAIG;gBACS,KAAK,CAAC,EAAE,MAAM;IAI1B;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAWjC;;OAEG;YACW,kBAAkB;IAkBhC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAWjC;;;;;OAKG;IACG,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAS5C;;;;;;OAMG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IAWtD;;OAEG;YACW,iBAAiB;CAKhC;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IAC3D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,UAAU;IAC3B,QAAQ,CAAC,KAAK,gBAAgB;IAE9B;;;;OAIG;gBACS,UAAU,GAAE,MAAY;IAIpC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAIjC;;;;;OAKG;IACG,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAe5C;;;;;OAKG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IAItD;;OAEG;IACH,OAAO,CAAC,UAAU;IAUlB;;OAEG;IACH,OAAO,CAAC,SAAS;CAalB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,gBAAgB,GAAG,IAAI,CAoBjG"}