@wgtechlabs/nuvex 0.1.1

package/dist/types/core/database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/core/database.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,IAAI,CAAC;AAC3C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAYrD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAM5E;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,CAAC,EAAE,oBAAoB,GAAG,MAAM,CA+D5E;AAED,eAAO,MAAM,gBAAgB,QAA2B,CAAC;AAEzD,MAAM,WAAW,kBAAkB;IACjC,gFAAgF;IAChF,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,yDAAyD;IACzD,MAAM,CAAC,EAAE,oBAAoB,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,QAAQ,EACZ,OAAO,GAAE,kBAAuB,EAChC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC,CAwBf;AAiDD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,qBAAqB,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,oBAAoB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAYzH;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,eAAe,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,EAAE,oBAAoB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBjH"}

package/dist/types/core/engine.d.ts

@@ -0,0 +1,450 @@
+/**
+ * Nuvex - Storage Engine
+ * Next-gen Unified Vault Experience
+ *
+ * Multi-layer storage architecture that provides intelligent caching and data
+ * persistence for any Node.js application. Implements a three-tier storage system
+ * optimized for performance, scalability, and reliability.
+ *
+ * Storage Architecture:
+ * - Layer 1: Memory Cache (configurable TTL) - Fastest access for hot data
+ * - Layer 2: Redis Cache (configurable TTL) - Fast distributed cache for warm data
+ * - Layer 3: PostgreSQL (Permanent) - Persistent storage for cold data
+ *
+ * Key Features:
+ * - Automatic data tier management and promotion/demotion
+ * - Configurable TTL (Time To Live) for each storage layer
+ * - Intelligent fallback mechanism between storage tiers
+ * - Memory cleanup and garbage collection
+ * - Connection pooling and error recovery
+ * - Pluggable logging support
+ *
+ * @author Waren Gonzaga, WG Technology Labs
+ * @since 2025
+ */
+import type { NuvexConfig, StorageOptions, BatchOperation, BatchResult, QueryOptions, QueryResult } from '../types/index.js';
+import type { Storage } from '../interfaces/index.js';
+/**
+ * # StorageEngine - Multi-layer Storage Architecture
+ *
+ * The core storage engine that implements Nuvex's intelligent three-tier storage system.
+ * Provides automatic data management, intelligent caching, and comprehensive fallback mechanisms
+ * across Memory, Redis, and PostgreSQL layers.
+ *
+ * ## Architecture Design
+ *
+ * The StorageEngine follows a hierarchical approach where data flows through layers based on
+ * access patterns and configured policies:
+ *
+ * ```
+ * ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
+ * │   Memory    │───▶│    Redis    │───▶│ PostgreSQL  │
+ * │ (Layer 1)   │    │ (Layer 2)   │    │ (Layer 3)   │
+ * │ < 1ms       │    │ 1-5ms       │    │ 5-50ms      │
+ * └─────────────┘    └─────────────┘    └─────────────┘
+ * ```
+ *
+ * ## Key Features
+ *
+ * ### Intelligent Data Management
+ * - **Automatic Promotion**: Frequently accessed data moves to faster layers
+ * - **Smart Demotion**: Unused data gracefully moves to persistent storage
+ * - **TTL Management**: Configurable time-to-live for each layer
+ * - **Memory Optimization**: LRU eviction and automatic cleanup
+ *
+ * ### Performance Optimization
+ * - **Sub-millisecond Access**: Memory cache for hot data
+ * - **Batch Operations**: Efficient bulk data operations
+ * - **Connection Pooling**: Optimized database connections
+ * - **Metrics Collection**: Real-time performance monitoring
+ *
+ * ### Reliability Features
+ * - **Graceful Degradation**: Automatic fallback when layers are unavailable
+ * - **Error Recovery**: Comprehensive error handling and logging
+ * - **Data Consistency**: Synchronization across all storage layers
+ * - **Health Monitoring**: Layer availability and performance tracking
+ *
+ * ## Usage Examples
+ *
+ * ### Basic Operations
+ * ```typescript
+ * const engine = new StorageEngine({
+ *   memory: { ttl: 3600000, maxSize: 10000 },
+ *   redis: { url: 'redis://localhost:6379' },
+ *   postgres: { host: 'localhost', database: 'app' }
+ * });
+ *
+ * await engine.connect();
+ *
+ * // Set data across all layers
+ * await engine.set('user:123', userData);
+ *
+ * // Get data (checks Memory → Redis → PostgreSQL)
+ * const user = await engine.get('user:123');
+ * ```
+ *
+ * ### Layer-specific Operations
+ * ```typescript
+ * // Store only in Redis
+ * await engine.set('session:abc', sessionData, {
+ *   layer: StorageLayer.REDIS
+ * });
+ *
+ * // Skip cache and go directly to PostgreSQL
+ * const criticalData = await engine.get('config:critical', {
+ *   skipCache: true
+ * });
+ * ```
+ *
+ * ### Batch Operations
+ * ```typescript
+ * const operations = [
+ *   { operation: 'set', key: 'key1', value: 'value1' },
+ *   { operation: 'set', key: 'key2', value: 'value2' }
+ * ];
+ *
+ * const results = await engine.setBatch(operations);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Initialize with full configuration
+ * const engine = new StorageEngine({
+ *   memory: {
+ *     ttl: 24 * 60 * 60 * 1000, // 24 hours
+ *     maxSize: 10000
+ *   },
+ *   redis: {
+ *     url: 'redis://localhost:6379',
+ *     ttl: 3 * 24 * 60 * 60 // 3 days
+ *   },
+ *   postgres: {
+ *     host: 'localhost',
+ *     port: 5432,
+ *     database: 'myapp',
+ *     user: 'user',
+ *     password: 'password'
+ *   },
+ *   logging: {
+ *     enabled: true,
+ *     logger: console
+ *   }
+ * });
+ *
+ * await engine.connect();
+ *
+ * // Your storage operations here...
+ *
+ * await engine.disconnect();
+ * ```
+ *
+ * @see {@link NuvexClient} for high-level client operations
+ * @see {@link NuvexConfig} for configuration options
+ * @see {@link StorageOptions} for operation-specific options
+ *
+ * @public
+ * @category Core
+ */
+export declare class StorageEngine implements Storage {
+    private l1Memory;
+    private l2Redis;
+    private l3Postgres;
+    private config;
+    private connected;
+    private cleanupInterval;
+    private logger;
+    private metrics;
+    /**
+     * Creates a new StorageEngine instance with the specified configuration.
+     *
+     * The constructor initializes all three storage layers and sets up automatic
+     * memory cleanup intervals. No connections are established until `connect()` is called.
+     *
+     * @param config - Complete configuration object for all storage layers
+     *
+     * @example
+     * ```typescript
+     * const engine = new StorageEngine({
+     *   memory: { ttl: 3600000, maxSize: 10000 },
+     *   redis: { url: 'redis://localhost:6379', ttl: 86400 },
+     *   postgres: { host: 'localhost', database: 'myapp' },
+     *   logging: { enabled: true }
+     * });
+     * ```
+     *
+     * @throws {Error} When configuration is invalid
+     * @since 1.0.0
+     */
+    constructor(config: NuvexConfig);
+    private log;
+    /**
+     * Establishes connections to all configured storage layers.
+     *
+     * This method initializes connections to Redis and PostgreSQL (if configured)
+     * and sets up the internal state for multi-layer operations. The memory layer
+     * is always available and doesn't require connection setup.
+     *
+     * @throws {Error} When connection to any configured layer fails
+     *
+     * @example
+     * ```typescript
+     * const engine = new StorageEngine(config);
+     * await engine.connect();
+     * console.log('All storage layers connected');
+     * ```
+     *
+     * @since 1.0.0
+     * @public
+     */
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    /**
+     * Retrieves a value from storage using the intelligent layer hierarchy.
+     *
+     * The get operation follows the multi-layer approach:
+     * 1. **Memory Cache**: Checks in-memory storage first (fastest)
+     * 2. **Redis Cache**: Falls back to Redis if not in memory
+     * 3. **PostgreSQL**: Final fallback to persistent storage
+     *
+     * When data is found in a lower layer, it's automatically promoted to higher
+     * layers for faster future access (intelligent caching).
+     *
+     * @template T - The expected type of the stored value
+     * @param key - The storage key to retrieve
+     * @param options - Optional configuration for the get operation
+     * @returns Promise resolving to the stored value or null if not found
+     *
+     * @example
+     * ```typescript
+     * // Basic get operation
+     * const userData = await engine.get<UserData>('user:123');
+     *
+     * // Get from specific layer only
+     * const sessionData = await engine.get('session:abc', {
+     *   layer: StorageLayer.REDIS
+     * });
+     *
+     * // Skip cache layers and get from PostgreSQL directly
+     * const criticalData = await engine.get('config:critical', {
+     *   skipCache: true
+     * });
+     * ```
+     *
+     * @since 1.0.0
+     * @public
+     */
+    get<T = unknown>(key: string, options?: StorageOptions): Promise<T | null>;
+    /**
+     * Set value in storage layers using L3-first write strategy
+     *
+     * **L3-First Write Strategy:**
+     * 1. Write to PostgreSQL (L3) first as source of truth
+     * 2. If L3 write succeeds, warm caches (L1, L2) using Promise.allSettled
+     * 3. Cache failures don't break the operation (graceful degradation)
+     *
+     * **Error Handling:**
+     * - Returns `false` if L3 (PostgreSQL) write fails - operation is aborted
+     * - Returns `false` if engine is not connected
+     * - Returns `true` if L3 write succeeds (cache failures are tolerated)
+     * - For memory/Redis-only deployments (no L3), cache write success determines result
+     *
+     * **Usage Recommendations:**
+     * ```typescript
+     * // Always check the return value for critical data
+     * const success = await engine.set('user:123', userData);
+     * if (!success) {
+     *   // Handle failure: retry, log, alert, or use fallback
+     *   console.error('Failed to persist user data');
+     *   throw new Error('Storage operation failed');
+     * }
+     *
+     * // For non-critical data, you may proceed regardless
+     * await engine.set('cache:temp', tempData); // Fire and forget
+     * ```
+     *
+     * @param key - The key to store
+     * @param value - The value to store
+     * @param options - Optional storage options (ttl, layer targeting)
+     * @returns Promise resolving to true if operation succeeded, false otherwise
+     */
+    set<T = unknown>(key: string, value: T, options?: StorageOptions): Promise<boolean>;
+    /**
+     * Delete from all storage layers using resilient approach
+     *
+     * Uses Promise.allSettled to attempt deletion from all layers without
+     * failing if individual layers are unavailable. This provides graceful
+     * degradation - even if cache layers fail, the operation continues.
+     *
+     * @param key - The key to delete
+     * @param options - Optional storage options (layer targeting)
+     * @returns Promise resolving to true if operation completed
+     */
+    delete(key: string, options?: StorageOptions): Promise<boolean>;
+    /**
+     * Check if key exists in any storage layer
+     */
+    exists(key: string, options?: StorageOptions): Promise<boolean>;
+    /**
+     * Set expiration for a key
+     *
+     * Note: This is a simplified implementation that re-sets the value with new TTL.
+     * For a more efficient implementation, layers would need an expire() method.
+     */
+    expire(key: string, ttl: number): Promise<boolean>;
+    /**
+     * Atomically increment a numeric value
+     *
+     * This method uses layer-specific atomic operations when available,
+     * providing thread-safe increments across all storage layers.
+     *
+     * **Important:** The key must contain a numeric value (or not exist).
+     * If the key contains a non-numeric value, the operation will fail:
+     * - Redis: Throws error "value is not an integer"
+     * - PostgreSQL: Throws error during numeric cast
+     * - Memory: Treats non-numeric values as 0
+     *
+     * The increment cascades through layers:
+     * 1. If L3 (PostgreSQL) is available, use its atomic UPSERT
+     * 2. Else if L2 (Redis) is available, use INCRBY
+     * 3. Else use L1 (Memory) increment
+     *
+     * After incrementing in the authoritative layer, the new value is
+     * propagated to higher layers for cache consistency.
+     *
+     * @param key - The key to increment (must contain numeric value or not exist)
+     * @param delta - The amount to increment by (default: 1)
+     * @param ttl - Optional TTL in milliseconds
+     * @returns Promise resolving to the new value after increment
+     * @throws {Error} If the key contains a non-numeric value (Redis/PostgreSQL)
+     * @throws {Error} If no storage layer is available
+     *
+     * @example
+     * ```typescript
+     * // Increment counter by 1
+     * const newValue = await engine.increment('page_views');
+     *
+     * // Increment with custom delta
+     * const credits = await engine.increment('user:credits', 10);
+     *
+     * // Decrement (negative delta)
+     * const remaining = await engine.increment('inventory', -1);
+     * ```
+     */
+    increment(key: string, delta?: number, ttl?: number): Promise<number>;
+    setBatch(operations: BatchOperation[]): Promise<BatchResult[]>;
+    getBatch(keys: string[], options?: StorageOptions): Promise<BatchResult[]>;
+    deleteBatch(keys: string[]): Promise<BatchResult[]>;
+    query<T = unknown>(options: QueryOptions): Promise<QueryResult<T>>;
+    /**
+     * Get all keys matching a pattern across all storage layers
+     *
+     * Collects keys from all available layers (Memory, Redis, PostgreSQL) and
+     * returns deduplicated results. Currently implemented for the Memory layer;
+     * Redis and PostgreSQL layer support will be added in future versions.
+     *
+     * @param pattern - Glob pattern for key matching (default: '*' returns all keys)
+     * @returns Promise resolving to array of unique matching keys
+     *
+     * @since 1.0.0
+     */
+    keys(pattern?: string): Promise<string[]>;
+    clear(pattern?: string): Promise<number>;
+    /**
+     * Get performance metrics for all layers or specific layer(s)
+     *
+     * Returns metrics about storage operations and performance. Can be filtered
+     * to return metrics for specific layers only.
+     *
+     * **Metrics by Layer:**
+     * - Memory: memoryHits, memoryMisses, memorySize, memoryMaxSize
+     * - Redis: redisHits, redisMisses
+     * - PostgreSQL: postgresHits, postgresMisses
+     * - Overall: totalOperations, cacheHitRatio, averageResponseTime
+     *
+     * @param layers - Optional layer(s) to get metrics for. If not provided, returns all metrics.
+     *                 Can be a single layer string, 'all', or array of layer strings.
+     * @returns Object containing requested metrics
+     *
+     * @example
+     * ```typescript
+     * // Get all metrics
+     * const metrics = engine.getMetrics();
+     * // { memoryHits, memoryMisses, redisHits, redisMisses, postgresHits, ... }
+     *
+     * // Get specific layer metrics
+     * const memoryMetrics = engine.getMetrics('memory');
+     * // { memoryHits, memoryMisses, memorySize, memoryMaxSize }
+     *
+     * // Get multiple layer metrics
+     * const cacheMetrics = engine.getMetrics(['memory', 'redis']);
+     * // { memoryHits, memoryMisses, memorySize, memoryMaxSize, redisHits, redisMisses, totalOperations, averageResponseTime, cacheHitRatio }
+     * ```
+     *
+     * @since 1.0.0
+     * @public
+     */
+    getMetrics(layers?: 'memory' | 'redis' | 'postgres' | 'all' | Array<'memory' | 'redis' | 'postgres'>): Record<string, number>;
+    resetMetrics(): void;
+    /**
+     * Perform health check on all storage layers or specific layer(s)
+     *
+     * Uses Promise.allSettled to check all layers independently without
+     * failing if one layer is down. Each layer's ping() method is called
+     * to verify its operational status.
+     *
+     * **Layer Health Checks:**
+     * - Memory (L1): Always healthy if app is running
+     * - Redis (L2): PING command verification
+     * - PostgreSQL (L3): SELECT 1 query verification
+     *
+     * @param layers - Optional layer(s) to check. If not provided, checks all layers.
+     *                 Can be a single layer string or array of layer strings.
+     * @returns Promise resolving to health status of requested layer(s)
+     *
+     * @example
+     * ```typescript
+     * // Check all layers
+     * const health = await engine.healthCheck();
+     * // { memory: true, redis: true, postgres: true }
+     *
+     * // Check specific layer
+     * const redisHealth = await engine.healthCheck('redis');
+     * // { redis: true }
+     *
+     * // Check multiple specific layers
+     * const cacheHealth = await engine.healthCheck(['memory', 'redis']);
+     * // { memory: true, redis: true }
+     *
+     * if (!health.redis) {
+     *   console.warn('Redis layer is down, degraded performance expected');
+     * }
+     * ```
+     *
+     * @since 1.0.0
+     * @public
+     */
+    healthCheck(layers?: 'memory' | 'redis' | 'postgres' | Array<'memory' | 'redis' | 'postgres'>): Promise<Record<string, boolean>>;
+    promote(key: string, targetLayer: string): Promise<boolean>;
+    demote(key: string, targetLayer: string): Promise<boolean>;
+    getLayerInfo(key: string): Promise<{
+        layer: string;
+        ttl?: number;
+    } | null>;
+    private startMemoryCleanup;
+    private updateResponseTime;
+    private calculateCacheHitRatio;
+    private applySorting;
+    private applyPagination;
+    getStats(): {
+        memoryKeys: number;
+        connected: boolean;
+        layers: {
+            memory: boolean;
+            redis: boolean;
+            postgres: boolean;
+        };
+    };
+    cleanupExpiredMemory(): Promise<number>;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/types/core/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/core/engine.ts"],"names":[],"mappings":"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"}

package/dist/types/core/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Nuvex - Core Module Exports
+ * Next-gen Unified Vault Experience
+ *
+ * Clean exports for all core components
+ *
+ * @author Waren Gonzaga, WG Technology Labs
+ * @since 2025
+ */
+export { StorageEngine } from './engine.js';
+export { NuvexClient } from './client.js';
+export * from './database.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAG5C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,cAAc,eAAe,CAAC"}

package/dist/types/index.d.ts

@@ -0,0 +1,85 @@
+/**
+ * # Nuvex - Next-gen Unified Vault Experience
+ *
+ * A production-ready, minimalist SDK for structured memory layering in Redis and PostgreSQL.
+ * Designed for any Node.js application that needs intelligent multi-layer storage with automatic
+ * data promotion, demotion, and comprehensive reliability features.
+ *
+ * ## Architecture Overview
+ *
+ * Nuvex implements a sophisticated three-tier storage system:
+ *
+ * ### Layer 1: Memory Cache (Ultra-fast)
+ * - **TTL**: Configurable (default: 24 hours)
+ * - **Use case**: Hot data, session information, frequently accessed content
+ * - **Performance**: Sub-millisecond access time
+ * - **Features**: LRU eviction, automatic cleanup, size limits
+ *
+ * ### Layer 2: Redis Cache (Fast & Distributed)
+ * - **TTL**: Configurable (default: 3 days)
+ * - **Use case**: Warm data, distributed caching across instances
+ * - **Performance**: 1-5ms access time
+ * - **Features**: Atomic operations, cluster support, persistence
+ *
+ * ### Layer 3: PostgreSQL (Persistent & Reliable)
+ * - **TTL**: Permanent storage with optional expiration
+ * - **Use case**: Cold data, critical information, audit trails
+ * - **Performance**: 5-50ms access time depending on query complexity
+ * - **Features**: ACID compliance, advanced querying, schema flexibility
+ *
+ * ## Key Components
+ *
+ * - **{@link StorageEngine}**: Low-level multi-layer storage implementation
+ * - **{@link NuvexClient}**: High-level client with convenience methods
+ * - **Database Utilities**: Schema management and migration tools
+ * - **Type System**: Comprehensive TypeScript definitions
+ *
+ * ## Quick Start Example
+ *
+ * ```typescript
+ * import { NuvexClient } from '@wgtechlabs/nuvex';
+ *
+ * const client = new NuvexClient({
+ *   memory: { ttl: 3600000, maxSize: 10000 },
+ *   redis: { url: 'redis://localhost:6379', ttl: 86400 },
+ *   postgres: {
+ *     host: 'localhost',
+ *     database: 'myapp',
+ *     user: 'user',
+ *     password: 'pass'
+ *   }
+ * });
+ *
+ * await client.connect();
+ *
+ * // Set data (automatically stored in all layers)
+ * await client.set('user:123', { name: 'John', email: 'john@example.com' });
+ *
+ * // Get data (automatically checks Memory → Redis → PostgreSQL)
+ * const user = await client.get('user:123');
+ * ```
+ *  * ## Use Cases
+ *
+ * - **Session Management**: Store user sessions with automatic expiration
+ * - **API Caching**: Cache API responses with intelligent invalidation
+ * - **Configuration Storage**: Store application settings with fallback
+ * - **Real-time Data**: Handle high-frequency data with performance optimization
+ * - **Application State**: Store application state and user preferences
+ * - **Microservices**: Shared data layer across distributed services
+ *
+ * @author Waren Gonzaga, WG Technology Labs
+ * @since 2025
+ * @see {@link https://github.com/wgtechlabs/nuvex} GitHub Repository
+ * @see {@link https://wgtechlabs.com} WG Technology Labs
+ *
+ * @packageDocumentation
+ */
+export { StorageEngine } from './core/engine.js';
+export { NuvexClient } from './core/client.js';
+export * from './core/database.js';
+export type * from './types/index.js';
+export type * from './interfaces/index.js';
+export { NuvexClient as Nuvex } from './core/client.js';
+export { NuvexClient as Client } from './core/client.js';
+export { StorageEngine as Engine } from './core/engine.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG/C,cAAc,oBAAoB,CAAC;AAGnC,mBAAmB,kBAAkB,CAAC;AACtC,mBAAmB,uBAAuB,CAAC;AAG3C,OAAO,EAAE,WAAW,IAAI,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAGxD,OAAO,EAAE,WAAW,IAAI,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,aAAa,IAAI,MAAM,EAAE,MAAM,kBAAkB,CAAC"}