@revealui/ai 0.1.0

package/dist/memory/utils/sql-helpers.js

@@ -0,0 +1,214 @@
+/**
+ * SQL Helper Utilities
+ *
+ * Provides type-safe raw SQL query helpers to work around Neon HTTP driver
+ * compatibility issues with Drizzle's relational query builder.
+ *
+ * These helpers use Drizzle's sql tagged template for type safety and
+ * SQL injection prevention.
+ */
+import { sql } from 'drizzle-orm';
+const getRows = (result) => {
+    if (Array.isArray(result)) {
+        return result;
+    }
+    if (result && typeof result === 'object' && Array.isArray(result.rows)) {
+        return result.rows;
+    }
+    return [];
+};
+// =============================================================================
+// Node ID Mappings Queries
+// =============================================================================
+/**
+ * Finds a node ID mapping by hash (primary key).
+ *
+ * @param db - Database client
+ * @param hash - SHA-256 hash of entity ID
+ * @returns Node ID mapping or undefined if not found
+ */
+export async function findNodeIdMappingByHash(db, hash) {
+    const result = await db.execute(sql `SELECT id, entity_type, entity_id, node_id, created_at, updated_at
+        FROM node_id_mappings
+        WHERE id = ${hash}
+        LIMIT 1`);
+    // Handle different result formats (Neon HTTP vs direct Postgres)
+    const rows = getRows(result);
+    if (!rows[0])
+        return undefined;
+    // Transform snake_case to camelCase to match NodeIdMappingsRow type
+    const row = rows[0];
+    return {
+        id: row.id,
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        nodeId: row.node_id,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * Finds a node ID mapping by entity ID and type.
+ *
+ * @param db - Database client
+ * @param entityType - Type of entity ('session' or 'user')
+ * @param entityId - Entity identifier
+ * @returns Node ID mapping or undefined if not found
+ */
+export async function findNodeIdMappingByEntity(db, entityType, entityId) {
+    const result = await db.execute(sql `SELECT id, entity_type, entity_id, node_id, created_at, updated_at
+        FROM node_id_mappings
+        WHERE entity_type = ${entityType} AND entity_id = ${entityId}
+        LIMIT 1`);
+    const rows = getRows(result);
+    if (!rows[0])
+        return undefined;
+    // Transform snake_case to camelCase to match NodeIdMappingsRow type
+    const row = rows[0];
+    return {
+        id: row.id,
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        nodeId: row.node_id,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+// =============================================================================
+// Agent Memories Queries
+// =============================================================================
+/**
+ * Finds an agent memory by ID (returns raw database record format).
+ *
+ * @deprecated Use VectorMemoryService.getById() instead. This function queries
+ * agent_memories which is now in the vector database (Supabase), not REST database.
+ * If you need to query memories, use VectorMemoryService which uses the correct database.
+ *
+ * @param db - Database client (NOTE: Should be vector client, but type doesn't enforce this)
+ * @param memoryId - Memory identifier
+ * @returns Raw database memory record or undefined if not found
+ */
+export async function findAgentMemoryById(db, memoryId) {
+    // NOTE: This queries agent_memories which is in vector database
+    // Using raw SQL so it works, but caller must use vector client
+    const result = await db.execute(sql `SELECT id, version, content, type, source, embedding, embedding_metadata, 
+               metadata, access_count, accessed_at, verified, verified_by, 
+               verified_at, site_id, agent_id, created_at, expires_at
+        FROM agent_memories 
+        WHERE id = ${memoryId} 
+        LIMIT 1`);
+    const rows = getRows(result);
+    if (!rows[0])
+        return undefined;
+    const row = rows[0];
+    return {
+        id: row.id,
+        version: row.version || 1,
+        content: row.content,
+        type: row.type,
+        source: row.source,
+        embedding: row.embedding,
+        embeddingMetadata: row.embedding_metadata,
+        metadata: row.metadata,
+        accessCount: row.access_count,
+        accessedAt: row.accessed_at,
+        verified: row.verified,
+        createdAt: row.created_at,
+        expiresAt: row.expires_at,
+    };
+}
+/**
+ * Finds agent memories by user ID.
+ *
+ * @deprecated Use VectorMemoryService.searchSimilar() or VectorMemoryService with filters instead.
+ * This function queries agent_memories which is now in the vector database (Supabase).
+ * If you need to query memories, use VectorMemoryService which uses the correct database.
+ *
+ * @param db - Database client (NOTE: Should be vector client, but type doesn't enforce this)
+ * @param userId - User identifier
+ * @returns Array of agent memories
+ */
+export async function findAgentMemoriesByUserId(db, userId) {
+    const result = await db.execute(sql `SELECT id, version, content, type, source, embedding, embedding_metadata, 
+               metadata, access_count, accessed_at, verified, verified_by, 
+               verified_at, site_id, agent_id, created_at, expires_at
+        FROM agent_memories 
+        WHERE (source->>'id')::text = ${userId} 
+        ORDER BY created_at DESC`);
+    const rows = getRows(result);
+    return rows.map((row) => {
+        const record = row;
+        const metadata = record.embedding_metadata;
+        return {
+            id: record.id,
+            version: record.version || 1,
+            content: record.content,
+            type: record.type,
+            source: record.source,
+            embedding: metadata
+                ? {
+                    model: metadata.model,
+                    vector: record.embedding || metadata.vector,
+                    dimension: metadata.dimension,
+                    generatedAt: metadata.generatedAt,
+                }
+                : undefined,
+            metadata: (record.metadata || {}),
+            accessedAt: record.accessed_at?.toISOString() || new Date().toISOString(),
+            accessCount: record.access_count || 0,
+            verified: record.verified ?? false,
+            createdAt: record.created_at,
+            expiresAt: record.expires_at,
+        };
+    });
+}
+// =============================================================================
+// Agent Contexts Queries
+// =============================================================================
+/**
+ * Finds an agent context by CRDT ID (returns raw database record format).
+ *
+ * @param db - Database client
+ * @param crdtId - CRDT identifier (format: sessionId:agentId)
+ * @returns Raw database context record or undefined if not found
+ */
+export async function findAgentContextById(db, crdtId) {
+    const result = await db.execute(sql `SELECT id, version, session_id, agent_id, context, priority, 
+               embedding, created_at, updated_at
+        FROM agent_contexts 
+        WHERE id = ${crdtId} 
+        LIMIT 1`);
+    const rows = getRows(result);
+    if (!rows[0])
+        return undefined;
+    const row = rows[0];
+    return {
+        id: row.id,
+        version: row.version || 1,
+        sessionId: row.session_id,
+        agentId: row.agent_id,
+        context: row.context || {},
+        priority: row.priority || 0.5,
+        embedding: row.embedding,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+// =============================================================================
+// Users Queries
+// =============================================================================
+/**
+ * Finds a user by ID.
+ *
+ * @param db - Database client
+ * @param userId - User identifier
+ * @returns User record or undefined if not found
+ */
+export async function findUserById(db, userId) {
+    const result = await db.execute(sql `SELECT id, preferences 
+        FROM users 
+        WHERE id = ${userId} 
+        LIMIT 1`);
+    const rows = getRows(result);
+    return rows[0];
+}

package/dist/memory/utils/validation.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Validation Utilities
+ *
+ * Provides validation functions for context keys, values, and objects
+ * to prevent security vulnerabilities and performance issues.
+ */
+/**
+ * Validates that a context key is safe to use.
+ *
+ * @param key - The key to validate
+ * @throws ValidationError if key is dangerous or invalid
+ */
+export declare function validateContextKey(key: string): void;
+/**
+ * Validates that a context value is safe to store.
+ *
+ * @param value - The value to validate
+ * @param key - The key this value is associated with (for error messages)
+ * @throws ValidationError if value is invalid
+ */
+export declare function validateContextValue(value: unknown, key: string): void;
+/**
+ * Validates the depth of a nested object structure.
+ *
+ * @param obj - The object to check
+ * @param maxDepth - Maximum allowed depth (default: MAX_OBJECT_DEPTH)
+ * @returns The actual depth of the object
+ * @throws Error if depth exceeds maximum
+ */
+export declare function validateObjectDepth(obj: unknown, maxDepth?: number): number;
+/**
+ * Estimates the approximate size of an object in bytes.
+ * This is a rough estimate for validation purposes.
+ *
+ * @param obj - The object to measure
+ * @returns Approximate size in bytes
+ */
+export declare function estimateObjectSize(obj: unknown): number;
+/**
+ * Validates that a context object is within size limits.
+ *
+ * @param context - The context object to validate
+ * @throws Error if context exceeds size limits
+ */
+export declare function validateContextSize(context: Record<string, unknown>): void;
+/**
+ * Validates a complete context object (keys, values, depth, size).
+ *
+ * @param context - The context object to validate
+ * @throws Error if any validation fails
+ */
+export declare function validateContext(context: Record<string, unknown>): void;
+/**
+ * Checks if an object contains circular references.
+ * This is a lightweight check that doesn't throw on circular refs,
+ * but can be used to detect them before operations that would fail.
+ *
+ * @param obj - The object to check
+ * @returns true if circular references are detected
+ */
+export declare function hasCircularReference(obj: unknown): boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/memory/utils/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/memory/utils/validation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAmCH;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAkBpD;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAYtE;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,SAAmB,GAAG,MAAM,CA4BrF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAwCvD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAY1E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAsCtE;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAkC1D"}

package/dist/memory/utils/validation.js

@@ -0,0 +1,244 @@
+/**
+ * Validation Utilities
+ *
+ * Provides validation functions for context keys, values, and objects
+ * to prevent security vulnerabilities and performance issues.
+ */
+import { ValidationError } from '../errors/index.js';
+/**
+ * Dangerous keys that could lead to prototype pollution or other security issues
+ */
+const DANGEROUS_KEYS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+    'hasOwnProperty',
+    'isPrototypeOf',
+    'propertyIsEnumerable',
+    'toLocaleString',
+    'toString',
+    'valueOf',
+]);
+/**
+ * Maximum allowed depth for nested objects (prevents stack overflow)
+ */
+const MAX_OBJECT_DEPTH = 100;
+/**
+ * Maximum allowed size for context objects (in bytes, approximate)
+ * This prevents memory exhaustion attacks
+ */
+const MAX_CONTEXT_SIZE = 10 * 1024 * 1024; // 10MB
+/**
+ * Maximum number of keys in a context object
+ */
+const MAX_CONTEXT_KEYS = 10000;
+/**
+ * Validates that a context key is safe to use.
+ *
+ * @param key - The key to validate
+ * @throws ValidationError if key is dangerous or invalid
+ */
+export function validateContextKey(key) {
+    if (typeof key !== 'string') {
+        throw new ValidationError(`Context key must be a string, got: ${typeof key}`);
+    }
+    if (key.length === 0) {
+        throw new ValidationError('Context key cannot be empty');
+    }
+    if (key.length > 256) {
+        throw new ValidationError(`Context key too long: ${key.length} characters (max 256)`);
+    }
+    if (DANGEROUS_KEYS.has(key)) {
+        throw new ValidationError(`Dangerous context key detected: ${key}. This key is not allowed for security reasons.`);
+    }
+}
+/**
+ * Validates that a context value is safe to store.
+ *
+ * @param value - The value to validate
+ * @param key - The key this value is associated with (for error messages)
+ * @throws ValidationError if value is invalid
+ */
+export function validateContextValue(value, key) {
+    if (value === undefined) {
+        throw new ValidationError(`Context values cannot be undefined. Key: ${key}`);
+    }
+    if (typeof value === 'function') {
+        throw new ValidationError(`Context values cannot be functions. Key: ${key}`);
+    }
+    if (typeof value === 'symbol') {
+        throw new ValidationError(`Context values cannot be symbols. Key: ${key}`);
+    }
+}
+/**
+ * Validates the depth of a nested object structure.
+ *
+ * @param obj - The object to check
+ * @param maxDepth - Maximum allowed depth (default: MAX_OBJECT_DEPTH)
+ * @returns The actual depth of the object
+ * @throws Error if depth exceeds maximum
+ */
+export function validateObjectDepth(obj, maxDepth = MAX_OBJECT_DEPTH) {
+    if (obj === null || typeof obj !== 'object') {
+        return 0;
+    }
+    if (Array.isArray(obj)) {
+        if (maxDepth <= 0) {
+            throw new ValidationError(`Object depth exceeds maximum of ${MAX_OBJECT_DEPTH}`);
+        }
+        let maxChildDepth = 0;
+        for (const item of obj) {
+            const childDepth = validateObjectDepth(item, maxDepth - 1);
+            maxChildDepth = Math.max(maxChildDepth, childDepth);
+        }
+        return maxChildDepth + 1;
+    }
+    if (maxDepth <= 0) {
+        throw new ValidationError(`Object depth exceeds maximum of ${MAX_OBJECT_DEPTH}`);
+    }
+    let maxChildDepth = 0;
+    const record = obj;
+    for (const value of Object.values(record)) {
+        const childDepth = validateObjectDepth(value, maxDepth - 1);
+        maxChildDepth = Math.max(maxChildDepth, childDepth);
+    }
+    return maxChildDepth + 1;
+}
+/**
+ * Estimates the approximate size of an object in bytes.
+ * This is a rough estimate for validation purposes.
+ *
+ * @param obj - The object to measure
+ * @returns Approximate size in bytes
+ */
+export function estimateObjectSize(obj) {
+    if (obj === null || obj === undefined) {
+        return 8; // null/undefined overhead
+    }
+    const type = typeof obj;
+    if (type === 'string') {
+        // UTF-16 char units × 2 bytes each. This over-estimates multi-byte UTF-8 code
+        // points but is intentionally conservative — the limit stays tighter than the
+        // real in-process memory cost, which is what we want for a safety bound.
+        return obj.length * 2 + 8;
+    }
+    if (type === 'number') {
+        return 8; // 64-bit float
+    }
+    if (type === 'boolean') {
+        return 4;
+    }
+    if (Array.isArray(obj)) {
+        let size = 8; // array overhead
+        for (const item of obj) {
+            size += estimateObjectSize(item);
+        }
+        return size;
+    }
+    if (type === 'object') {
+        let size = 8; // object overhead
+        const record = obj;
+        for (const [key, value] of Object.entries(record)) {
+            size += key.length * 2 + 8; // key size
+            size += estimateObjectSize(value);
+        }
+        return size;
+    }
+    return 8; // fallback
+}
+/**
+ * Validates that a context object is within size limits.
+ *
+ * @param context - The context object to validate
+ * @throws Error if context exceeds size limits
+ */
+export function validateContextSize(context) {
+    const keyCount = Object.keys(context).length;
+    if (keyCount > MAX_CONTEXT_KEYS) {
+        throw new ValidationError(`Context has too many keys: ${keyCount} (max ${MAX_CONTEXT_KEYS})`);
+    }
+    const estimatedSize = estimateObjectSize(context);
+    if (estimatedSize > MAX_CONTEXT_SIZE) {
+        throw new ValidationError(`Context too large: ~${Math.round(estimatedSize / 1024)}KB (max ${Math.round(MAX_CONTEXT_SIZE / 1024)}KB)`);
+    }
+}
+/**
+ * Validates a complete context object (keys, values, depth, size).
+ *
+ * @param context - The context object to validate
+ * @throws Error if any validation fails
+ */
+export function validateContext(context) {
+    // Validate size first (fast check)
+    validateContextSize(context);
+    // Validate each key-value pair
+    // Use Object.getOwnPropertyNames() to catch non-enumerable properties like __proto__
+    // when set via Object.defineProperty() or similar
+    const allKeys = Object.getOwnPropertyNames(context);
+    for (const key of allKeys) {
+        // Skip non-enumerable properties that aren't dangerous (like length on arrays)
+        // But always check dangerous keys even if non-enumerable
+        if (DANGEROUS_KEYS.has(key)) {
+            validateContextKey(key);
+            const value = context[key];
+            validateContextValue(value, key);
+        }
+        else {
+            // For enumerable properties, validate normally
+            const descriptor = Object.getOwnPropertyDescriptor(context, key);
+            if (descriptor?.enumerable) {
+                validateContextKey(key);
+                const value = context[key];
+                validateContextValue(value, key);
+            }
+        }
+    }
+    // Also check if __proto__ exists as a property (even if not enumerable)
+    // This catches cases where __proto__ is set via Object.defineProperty()
+    if (Object.hasOwn(context, '__proto__')) {
+        validateContextKey('__proto__');
+        const protoDescriptor = Object.getOwnPropertyDescriptor(context, '__proto__');
+        const value = protoDescriptor && 'value' in protoDescriptor ? protoDescriptor.value : undefined;
+        validateContextValue(value, '__proto__');
+    }
+    // Validate depth
+    validateObjectDepth(context);
+}
+/**
+ * Checks if an object contains circular references.
+ * This is a lightweight check that doesn't throw on circular refs,
+ * but can be used to detect them before operations that would fail.
+ *
+ * @param obj - The object to check
+ * @returns true if circular references are detected
+ */
+export function hasCircularReference(obj) {
+    const visited = new WeakSet();
+    function check(value) {
+        if (value === null || typeof value !== 'object') {
+            return false;
+        }
+        const current = value;
+        if (visited.has(current)) {
+            return true; // Circular reference detected
+        }
+        visited.add(current);
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (check(item)) {
+                    return true;
+                }
+            }
+        }
+        else {
+            const record = value;
+            for (const item of Object.values(record)) {
+                if (check(item)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    return check(obj);
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Vector Search implementations
+ *
+ * Semantic search capabilities using pgvector:
+ * - Embedding generation (OpenAI, local models)
+ * - Similarity search
+ * - Hybrid search (vector + metadata)
+ *
+ * @packageDocumentation
+ */
+export { VectorMemoryService, type VectorSearchOptions, type VectorSearchResult, } from './vector-memory-service.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/memory/vector/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,GACxB,MAAM,4BAA4B,CAAA"}

package/dist/memory/vector/index.js

@@ -0,0 +1,14 @@
+/**
+ * Vector Search implementations
+ *
+ * Semantic search capabilities using pgvector:
+ * - Embedding generation (OpenAI, local models)
+ * - Similarity search
+ * - Hybrid search (vector + metadata)
+ *
+ * @packageDocumentation
+ */
+export { VectorMemoryService, } from './vector-memory-service.js';
+// Vector implementations will be added here
+// export { generateEmbedding, type EmbeddingOptions } from './embeddings.js'
+// export { semanticSearch, hybridSearch, type SearchOptions } from './search.js'

package/dist/memory/vector/vector-memory-service.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Vector Memory Service
+ *
+ * Service for managing agent memories in Supabase with vector search capabilities.
+ * Uses pgvector for semantic similarity search.
+ *
+ * @example
+ * ```typescript
+ * import { VectorMemoryService } from '@revealui/ai/memory/vector/vector-memory-service'
+ *
+ * const service = new VectorMemoryService()
+ * const memories = await service.searchSimilar(embedding, { siteId: 'site-123', limit: 10 })
+ * ```
+ */
+import type { AgentMemory } from '@revealui/contracts/agents';
+export interface VectorSearchOptions {
+    userId?: string;
+    siteId?: string;
+    agentId?: string;
+    type?: string;
+    limit?: number;
+    threshold?: number;
+}
+export interface VectorSearchResult {
+    memory: AgentMemory;
+    similarity: number;
+}
+/**
+ * Vector Memory Service for semantic search operations.
+ */
+export declare class VectorMemoryService {
+    private _db;
+    /**
+     * Lazy-load database client to avoid connection initialization at module import time.
+     * This allows the module to be imported in test environments without triggering database connections.
+     */
+    private get db();
+    /**
+     * Search for similar memories using vector similarity.
+     *
+     * @param queryEmbedding - Query embedding vector (768 dimensions — Ollama nomic-embed-text)
+     * @param options - Search options (filtering, limits, etc.)
+     * @returns Array of memories with similarity scores, sorted by similarity (highest first)
+     *
+     * @example
+     * ```typescript
+     * const embedding = await generateEmbedding('user prefers dark theme')
+     * const results = await service.searchSimilar(embedding, {
+     *   siteId: 'site-123',
+     *   limit: 10,
+     *   threshold: 0.7
+     * })
+     * ```
+     */
+    searchSimilar(queryEmbedding: number[], options?: VectorSearchOptions): Promise<VectorSearchResult[]>;
+    /**
+     * Create a new memory in the vector database.
+     *
+     * @param memory - Memory to create (without id, createdAt, accessedAt)
+     * @returns Created memory with generated id and timestamps
+     */
+    create(memory: Omit<AgentMemory, 'id' | 'createdAt' | 'accessedAt'> & {
+        id?: string;
+    }): Promise<AgentMemory>;
+    /**
+     * Update an existing memory.
+     *
+     * @param id - Memory ID
+     * @param updates - Partial memory updates
+     * @returns Updated memory
+     */
+    update(id: string, updates: Partial<Omit<AgentMemory, 'id' | 'createdAt'>>): Promise<AgentMemory>;
+    /**
+     * Delete a memory by ID.
+     *
+     * @param id - Memory ID to delete
+     * @returns true if memory was deleted
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Get a memory by ID.
+     *
+     * @param id - Memory ID
+     * @returns Memory if found, null otherwise
+     */
+    getById(id: string): Promise<AgentMemory | null>;
+}
+//# sourceMappingURL=vector-memory-service.d.ts.map

package/dist/memory/vector/vector-memory-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-memory-service.d.ts","sourceRoot":"","sources":["../../../src/memory/vector/vector-memory-service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAK7D,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,WAAW,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,GAAG,CAAkD;IAE7D;;;OAGG;IACH,OAAO,KAAK,EAAE,GAKb;IAED;;;;;;;;;;;;;;;;OAgBG;IACG,aAAa,CACjB,cAAc,EAAE,MAAM,EAAE,EACxB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,kBAAkB,EAAE,CAAC;IA2GhC;;;;;OAKG;IACG,MAAM,CACV,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,WAAW,GAAG,YAAY,CAAC,GAAG;QAC7D,EAAE,CAAC,EAAE,MAAM,CAAA;KACZ,GACA,OAAO,CAAC,WAAW,CAAC;IAmEvB;;;;;;OAMG;IACG,MAAM,CACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,GAAG,WAAW,CAAC,CAAC,GACtD,OAAO,CAAC,WAAW,CAAC;IAyEvB;;;;;OAKG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAK1C;;;;;OAKG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;CA8CvD"}