@hazeljs/cache 0.2.0-alpha.1

package/dist/decorators/cache.decorator.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = Cache;
+exports.getCacheMetadata = getCacheMetadata;
+exports.hasCacheMetadata = hasCacheMetadata;
+exports.CacheKey = CacheKey;
+exports.CacheTTL = CacheTTL;
+exports.CacheTags = CacheTags;
+exports.CacheEvict = CacheEvict;
+exports.getCacheEvictMetadata = getCacheEvictMetadata;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+const CACHE_METADATA_KEY = 'hazel:cache';
+/**
+ * Cache decorator for methods
+ *
+ * @example
+ * ```typescript
+ * @Cache({
+ *   strategy: 'memory',
+ *   ttl: 3600,
+ *   key: 'user-{id}',
+ *   tags: ['users']
+ * })
+ * @Get('/users/:id')
+ * async getUser(@Param('id') id: string) {
+ *   return this.userService.findById(id);
+ * }
+ * ```
+ */
+function Cache(options = {}) {
+    return (target, propertyKey, descriptor) => {
+        const defaults = {
+            strategy: 'memory',
+            ttl: 3600,
+            ttlStrategy: 'absolute',
+            cacheNull: false,
+            ...options,
+        };
+        // Store metadata
+        Reflect.defineMetadata(CACHE_METADATA_KEY, defaults, target, propertyKey);
+        core_1.default.debug(`Cache decorator applied to ${target.constructor.name}.${String(propertyKey)}`);
+        // Note: The actual caching logic will be implemented by the CacheInterceptor
+        // This decorator just marks the method and stores configuration
+        return descriptor;
+    };
+}
+/**
+ * Get cache metadata from a method
+ */
+function getCacheMetadata(target, propertyKey) {
+    return Reflect.getMetadata(CACHE_METADATA_KEY, target, propertyKey);
+}
+/**
+ * Check if a method has cache metadata
+ */
+function hasCacheMetadata(target, propertyKey) {
+    return Reflect.hasMetadata(CACHE_METADATA_KEY, target, propertyKey);
+}
+/**
+ * CacheKey decorator to specify custom cache key generation
+ *
+ * @example
+ * ```typescript
+ * @CacheKey('user-{id}-{role}')
+ * @Get('/users/:id')
+ * async getUser(@Param('id') id: string, @Query('role') role: string) {
+ *   return this.userService.findById(id);
+ * }
+ * ```
+ */
+function CacheKey(keyPattern) {
+    return (target, propertyKey, descriptor) => {
+        const existingMetadata = getCacheMetadata(target, propertyKey) || {};
+        const updatedMetadata = {
+            ...existingMetadata,
+            key: keyPattern,
+        };
+        Reflect.defineMetadata(CACHE_METADATA_KEY, updatedMetadata, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * CacheTTL decorator to specify cache TTL
+ *
+ * @example
+ * ```typescript
+ * @CacheTTL(7200) // 2 hours
+ * @Get('/users')
+ * async getUsers() {
+ *   return this.userService.findAll();
+ * }
+ * ```
+ */
+function CacheTTL(ttl) {
+    return (target, propertyKey, descriptor) => {
+        const existingMetadata = getCacheMetadata(target, propertyKey) || {};
+        const updatedMetadata = {
+            ...existingMetadata,
+            ttl,
+        };
+        Reflect.defineMetadata(CACHE_METADATA_KEY, updatedMetadata, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * CacheTags decorator to specify cache tags
+ *
+ * @example
+ * ```typescript
+ * @CacheTags(['users', 'profiles'])
+ * @Get('/users/:id/profile')
+ * async getUserProfile(@Param('id') id: string) {
+ *   return this.userService.getProfile(id);
+ * }
+ * ```
+ */
+function CacheTags(tags) {
+    return (target, propertyKey, descriptor) => {
+        const existingMetadata = getCacheMetadata(target, propertyKey) || {};
+        const updatedMetadata = {
+            ...existingMetadata,
+            tags,
+        };
+        Reflect.defineMetadata(CACHE_METADATA_KEY, updatedMetadata, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * CacheEvict decorator to evict cache entries
+ *
+ * @example
+ * ```typescript
+ * @CacheEvict({ tags: ['users'] })
+ * @Post('/users')
+ * async createUser(@Body() user: CreateUserDto) {
+ *   return this.userService.create(user);
+ * }
+ * ```
+ */
+function CacheEvict(options) {
+    return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata('hazel:cache:evict', options, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * Get cache evict metadata
+ */
+function getCacheEvictMetadata(target, propertyKey) {
+    return Reflect.getMetadata('hazel:cache:evict', target, propertyKey);
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @hazeljs/cache - Caching module for HazelJS
+ */
+export { CacheModule, type CacheModuleOptions } from './cache.module';
+export { CacheService, CacheManager } from './cache.service';
+export { Cache, CacheKey, CacheTTL, CacheTags, CacheEvict, getCacheMetadata, hasCacheMetadata, getCacheEvictMetadata, } from './decorators/cache.decorator';
+export { type CacheOptions, type CacheStrategy, type TTLStrategy, type CacheEntry, type CacheStats, type ICacheStore, type CacheWarmingOptions, type CacheInvalidationEvent, } from './cache.types';
+export { MemoryCacheStore } from './strategies/memory.strategy';
+export { RedisCacheStore } from './strategies/redis.strategy';
+export { MultiTierCacheStore } from './strategies/multi-tier.strategy';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EACL,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,GAC5B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @hazeljs/cache - Caching module for HazelJS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiTierCacheStore = exports.RedisCacheStore = exports.MemoryCacheStore = exports.getCacheEvictMetadata = exports.hasCacheMetadata = exports.getCacheMetadata = exports.CacheEvict = exports.CacheTags = exports.CacheTTL = exports.CacheKey = exports.Cache = exports.CacheManager = exports.CacheService = exports.CacheModule = void 0;
+var cache_module_1 = require("./cache.module");
+Object.defineProperty(exports, "CacheModule", { enumerable: true, get: function () { return cache_module_1.CacheModule; } });
+var cache_service_1 = require("./cache.service");
+Object.defineProperty(exports, "CacheService", { enumerable: true, get: function () { return cache_service_1.CacheService; } });
+Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return cache_service_1.CacheManager; } });
+var cache_decorator_1 = require("./decorators/cache.decorator");
+Object.defineProperty(exports, "Cache", { enumerable: true, get: function () { return cache_decorator_1.Cache; } });
+Object.defineProperty(exports, "CacheKey", { enumerable: true, get: function () { return cache_decorator_1.CacheKey; } });
+Object.defineProperty(exports, "CacheTTL", { enumerable: true, get: function () { return cache_decorator_1.CacheTTL; } });
+Object.defineProperty(exports, "CacheTags", { enumerable: true, get: function () { return cache_decorator_1.CacheTags; } });
+Object.defineProperty(exports, "CacheEvict", { enumerable: true, get: function () { return cache_decorator_1.CacheEvict; } });
+Object.defineProperty(exports, "getCacheMetadata", { enumerable: true, get: function () { return cache_decorator_1.getCacheMetadata; } });
+Object.defineProperty(exports, "hasCacheMetadata", { enumerable: true, get: function () { return cache_decorator_1.hasCacheMetadata; } });
+Object.defineProperty(exports, "getCacheEvictMetadata", { enumerable: true, get: function () { return cache_decorator_1.getCacheEvictMetadata; } });
+var memory_strategy_1 = require("./strategies/memory.strategy");
+Object.defineProperty(exports, "MemoryCacheStore", { enumerable: true, get: function () { return memory_strategy_1.MemoryCacheStore; } });
+var redis_strategy_1 = require("./strategies/redis.strategy");
+Object.defineProperty(exports, "RedisCacheStore", { enumerable: true, get: function () { return redis_strategy_1.RedisCacheStore; } });
+var multi_tier_strategy_1 = require("./strategies/multi-tier.strategy");
+Object.defineProperty(exports, "MultiTierCacheStore", { enumerable: true, get: function () { return multi_tier_strategy_1.MultiTierCacheStore; } });

package/dist/strategies/memory.strategy.d.ts

@@ -0,0 +1,73 @@
+import { ICacheStore, CacheStats } from '../cache.types';
+/**
+ * In-memory cache store implementation
+ */
+export declare class MemoryCacheStore implements ICacheStore {
+    private cleanupIntervalMs;
+    private cache;
+    private tagIndex;
+    private stats;
+    private cleanupInterval?;
+    constructor(cleanupIntervalMs?: number);
+    /**
+     * Get a value from cache
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Set a value in cache
+     */
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Set a value with tags
+     */
+    setWithTags<T>(key: string, value: T, ttl: number, tags?: string[]): Promise<void>;
+    /**
+     * Delete a value from cache
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Delete entries by tag
+     */
+    deleteByTag(tag: string): Promise<void>;
+    /**
+     * Check if key exists in cache
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Clear all cache entries
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all keys matching a pattern
+     */
+    keys(pattern?: string): Promise<string[]>;
+    /**
+     * Get cache statistics
+     */
+    getStats(): Promise<CacheStats>;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Start cleanup interval
+     */
+    private startCleanup;
+    /**
+     * Stop cleanup interval
+     */
+    stopCleanup(): void;
+    /**
+     * Cleanup expired entries
+     */
+    private cleanup;
+    /**
+     * Remove key from tag index
+     */
+    private removeFromTagIndex;
+    /**
+     * Destroy the cache store
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=memory.strategy.d.ts.map

package/dist/strategies/memory.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.strategy.d.ts","sourceRoot":"","sources":["../../src/strategies/memory.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAc,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGrE;;GAEG;AACH,qBAAa,gBAAiB,YAAW,WAAW;IAStC,OAAO,CAAC,iBAAiB;IARrC,OAAO,CAAC,KAAK,CAAsC;IACnD,OAAO,CAAC,QAAQ,CAAuC;IACvD,OAAO,CAAC,KAAK,CAGX;IACF,OAAO,CAAC,eAAe,CAAC,CAAiB;gBAErB,iBAAiB,GAAE,MAAc;IAIrD;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IA4B5C;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,GAAE,MAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IActE;;OAEG;IACG,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BxF;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASxC;;OAEG;IACG,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc7C;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAY/C;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IAoBrC;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACH,OAAO,CAAC,YAAY;IAMpB;;OAEG;IACH,WAAW,IAAI,IAAI;IAOnB;;OAEG;IACH,OAAO,CAAC,OAAO;IAiBf;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAgB1B;;OAEG;IACH,OAAO,IAAI,IAAI;CAKhB"}

package/dist/strategies/memory.strategy.js

@@ -0,0 +1,236 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCacheStore = void 0;
+const core_1 = __importDefault(require("@hazeljs/core"));
+/**
+ * In-memory cache store implementation
+ */
+class MemoryCacheStore {
+    constructor(cleanupIntervalMs = 60000) {
+        this.cleanupIntervalMs = cleanupIntervalMs;
+        this.cache = new Map();
+        this.tagIndex = new Map();
+        this.stats = {
+            hits: 0,
+            misses: 0,
+        };
+        this.startCleanup();
+    }
+    /**
+     * Get a value from cache
+     */
+    async get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            core_1.default.debug(`Cache miss: ${key}`);
+            return null;
+        }
+        // Check if expired
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            this.removeFromTagIndex(key, entry.tags);
+            this.stats.misses++;
+            core_1.default.debug(`Cache expired: ${key}`);
+            return null;
+        }
+        // Update last accessed for sliding TTL
+        if (entry.lastAccessedAt !== undefined) {
+            entry.lastAccessedAt = Date.now();
+        }
+        this.stats.hits++;
+        core_1.default.debug(`Cache hit: ${key}`);
+        return entry.value;
+    }
+    /**
+     * Set a value in cache
+     */
+    async set(key, value, ttl = 3600) {
+        const now = Date.now();
+        const entry = {
+            value,
+            key,
+            cachedAt: now,
+            expiresAt: now + ttl * 1000,
+            lastAccessedAt: now,
+        };
+        this.cache.set(key, entry);
+        core_1.default.debug(`Cache set: ${key} (TTL: ${ttl}s)`);
+    }
+    /**
+     * Set a value with tags
+     */
+    async setWithTags(key, value, ttl, tags) {
+        const now = Date.now();
+        const entry = {
+            value,
+            key,
+            cachedAt: now,
+            expiresAt: now + ttl * 1000,
+            lastAccessedAt: now,
+            tags,
+        };
+        this.cache.set(key, entry);
+        // Update tag index
+        if (tags) {
+            tags.forEach((tag) => {
+                if (!this.tagIndex.has(tag)) {
+                    this.tagIndex.set(tag, new Set());
+                }
+                this.tagIndex.get(tag).add(key);
+            });
+        }
+        core_1.default.debug(`Cache set with tags: ${key} (TTL: ${ttl}s, Tags: ${tags?.join(', ')})`);
+    }
+    /**
+     * Delete a value from cache
+     */
+    async delete(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            this.removeFromTagIndex(key, entry.tags);
+        }
+        this.cache.delete(key);
+        core_1.default.debug(`Cache deleted: ${key}`);
+    }
+    /**
+     * Delete entries by tag
+     */
+    async deleteByTag(tag) {
+        const keys = this.tagIndex.get(tag);
+        if (!keys) {
+            return;
+        }
+        for (const key of keys) {
+            await this.delete(key);
+        }
+        this.tagIndex.delete(tag);
+        core_1.default.debug(`Cache invalidated by tag: ${tag} (${keys.size} entries)`);
+    }
+    /**
+     * Check if key exists in cache
+     */
+    async has(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return false;
+        }
+        // Check if expired
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            this.removeFromTagIndex(key, entry.tags);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Clear all cache entries
+     */
+    async clear() {
+        this.cache.clear();
+        this.tagIndex.clear();
+        core_1.default.info('Cache cleared');
+    }
+    /**
+     * Get all keys matching a pattern
+     */
+    async keys(pattern) {
+        const allKeys = Array.from(this.cache.keys());
+        if (!pattern) {
+            return allKeys;
+        }
+        // Simple pattern matching (supports * wildcard)
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
+        return allKeys.filter((key) => regex.test(key));
+    }
+    /**
+     * Get cache statistics
+     */
+    async getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        const hitRate = total > 0 ? (this.stats.hits / total) * 100 : 0;
+        // Calculate approximate memory usage
+        let memoryUsage = 0;
+        for (const entry of this.cache.values()) {
+            const entrySize = JSON.stringify(entry.value).length;
+            memoryUsage += entrySize;
+        }
+        return {
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            hitRate: Math.round(hitRate * 100) / 100,
+            size: this.cache.size,
+            memoryUsage,
+        };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats.hits = 0;
+        this.stats.misses = 0;
+    }
+    /**
+     * Start cleanup interval
+     */
+    startCleanup() {
+        this.cleanupInterval = setInterval(() => {
+            this.cleanup();
+        }, this.cleanupIntervalMs);
+    }
+    /**
+     * Stop cleanup interval
+     */
+    stopCleanup() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+    }
+    /**
+     * Cleanup expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        let expiredCount = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (now > entry.expiresAt) {
+                this.cache.delete(key);
+                this.removeFromTagIndex(key, entry.tags);
+                expiredCount++;
+            }
+        }
+        if (expiredCount > 0) {
+            core_1.default.debug(`Cleaned up ${expiredCount} expired cache entries`);
+        }
+    }
+    /**
+     * Remove key from tag index
+     */
+    removeFromTagIndex(key, tags) {
+        if (!tags) {
+            return;
+        }
+        tags.forEach((tag) => {
+            const keys = this.tagIndex.get(tag);
+            if (keys) {
+                keys.delete(key);
+                if (keys.size === 0) {
+                    this.tagIndex.delete(tag);
+                }
+            }
+        });
+    }
+    /**
+     * Destroy the cache store
+     */
+    destroy() {
+        this.stopCleanup();
+        this.cache.clear();
+        this.tagIndex.clear();
+    }
+}
+exports.MemoryCacheStore = MemoryCacheStore;

package/dist/strategies/multi-tier.strategy.d.ts

@@ -0,0 +1,69 @@
+import { ICacheStore, CacheStats } from '../cache.types';
+/**
+ * Multi-tier cache store implementation
+ * Uses memory cache as L1 and Redis as L2
+ */
+export declare class MultiTierCacheStore implements ICacheStore {
+    private l1Cache;
+    private l2Cache;
+    constructor(options?: {
+        redis?: {
+            host?: string;
+            port?: number;
+            password?: string;
+        };
+    });
+    /**
+     * Get a value from cache (L1 first, then L2)
+     */
+    get<T>(key: string): Promise<T | null>;
+    /**
+     * Set a value in cache (both L1 and L2)
+     */
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Set a value with tags
+     */
+    setWithTags<T>(key: string, value: T, ttl: number, tags?: string[]): Promise<void>;
+    /**
+     * Delete a value from cache (both L1 and L2)
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * Delete entries by tag
+     */
+    deleteByTag(tag: string): Promise<void>;
+    /**
+     * Check if key exists in cache
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * Clear all cache entries
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all keys matching a pattern
+     */
+    keys(pattern?: string): Promise<string[]>;
+    /**
+     * Get cache statistics
+     */
+    getStats(): Promise<CacheStats>;
+    /**
+     * Get L1 cache statistics
+     */
+    getL1Stats(): Promise<CacheStats>;
+    /**
+     * Get L2 cache statistics
+     */
+    getL2Stats(): Promise<CacheStats>;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Destroy the cache store
+     */
+    destroy(): Promise<void>;
+}
+//# sourceMappingURL=multi-tier.strategy.d.ts.map

package/dist/strategies/multi-tier.strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-tier.strategy.d.ts","sourceRoot":"","sources":["../../src/strategies/multi-tier.strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAKzD;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IACrD,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,OAAO,CAAkB;gBAErB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;IAMrF;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAqB5C;;OAEG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,GAAE,MAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAUtE;;OAEG;IACG,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAWxF;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMxC;;OAEG;IACG,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM7C;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IASxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;OAEG;IACG,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAW/C;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;IAqBrC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAIvC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAIvC;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}