@taicode/common-base 3.7.4 → 3.7.7

package/output/lru-cache/lru-cache.test.js

@@ -1,239 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { LruCache } from './lru-cache.js';
-describe('LruCache', () => {
-    describe('构造函数', () => {
-        it('应该创建默认容量为100的缓存', () => {
-            const cache = new LruCache();
-            expect(cache.capacity).toBe(100);
-            expect(cache.size).toBe(0);
-        });
-        it('应该创建指定容量的缓存', () => {
-            const cache = new LruCache(50);
-            expect(cache.capacity).toBe(50);
-            expect(cache.size).toBe(0);
-        });
-        it('应该在容量小于等于0时抛出错误', () => {
-            expect(() => new LruCache(0)).toThrow('maxSize must be greater than 0');
-            expect(() => new LruCache(-1)).toThrow('maxSize must be greater than 0');
-        });
-    });
-    describe('基本操作', () => {
-        it('应该能设置和获取值', () => {
-            const cache = new LruCache(3);
-            cache.set('key1', 'value1');
-            expect(cache.get('key1')).toBe('value1');
-            expect(cache.size).toBe(1);
-        });
-        it('应该在键不存在时返回undefined', () => {
-            const cache = new LruCache(3);
-            expect(cache.get('nonexistent')).toBeUndefined();
-        });
-        it('应该正确检查键是否存在', () => {
-            const cache = new LruCache(3);
-            expect(cache.has('key1')).toBe(false);
-            cache.set('key1', 'value1');
-            expect(cache.has('key1')).toBe(true);
-        });
-        it('应该能更新现有键的值', () => {
-            const cache = new LruCache(3);
-            cache.set('key1', 'value1');
-            cache.set('key1', 'updated_value1');
-            expect(cache.get('key1')).toBe('updated_value1');
-            expect(cache.size).toBe(1);
-        });
-        it('应该能删除键', () => {
-            const cache = new LruCache(3);
-            cache.set('key1', 'value1');
-            expect(cache.delete('key1')).toBe(true);
-            expect(cache.has('key1')).toBe(false);
-            expect(cache.size).toBe(0);
-        });
-        it('应该在删除不存在的键时返回false', () => {
-            const cache = new LruCache(3);
-            expect(cache.delete('nonexistent')).toBe(false);
-        });
-        it('应该能清空缓存', () => {
-            const cache = new LruCache(3);
-            cache.set('key1', 'value1');
-            cache.set('key2', 'value2');
-            cache.clear();
-            expect(cache.size).toBe(0);
-            expect(cache.has('key1')).toBe(false);
-            expect(cache.has('key2')).toBe(false);
-        });
-    });
-    describe('LRU 行为', () => {
-        it('应该在达到容量限制时移除最久未使用的项', () => {
-            const cache = new LruCache(2);
-            cache.set('key1', 'value1');
-            cache.set('key2', 'value2');
-            cache.set('key3', 'value3'); // 这应该移除 key1
-            expect(cache.has('key1')).toBe(false);
-            expect(cache.has('key2')).toBe(true);
-            expect(cache.has('key3')).toBe(true);
-            expect(cache.size).toBe(2);
-        });
-        it('应该在访问时更新使用顺序', () => {
-            const cache = new LruCache(2);
-            cache.set('key1', 'value1');
-            cache.set('key2', 'value2');
-            cache.get('key1'); // 使 key1 成为最近使用的
-            cache.set('key3', 'value3'); // 这应该移除 key2，而不是 key1
-            expect(cache.has('key1')).toBe(true);
-            expect(cache.has('key2')).toBe(false);
-            expect(cache.has('key3')).toBe(true);
-        });
-        it('应该在更新现有键时保持其为最近使用', () => {
-            const cache = new LruCache(2);
-            cache.set('key1', 'value1');
-            cache.set('key2', 'value2');
-            cache.set('key1', 'updated_value1'); // 更新 key1
-            cache.set('key3', 'value3'); // 这应该移除 key2
-            expect(cache.has('key1')).toBe(true);
-            expect(cache.get('key1')).toBe('updated_value1');
-            expect(cache.has('key2')).toBe(false);
-            expect(cache.has('key3')).toBe(true);
-        });
-    });
-    describe('遍历方法', () => {
-        it('应该返回正确的键列表（按使用顺序）', () => {
-            const cache = new LruCache(3);
-            cache.set('key1', 'value1');
-            cache.set('key2', 'value2');
-            cache.set('key3', 'value3');
-            cache.get('key1'); // 使 key1 成为最近使用的
-            const keys = cache.keys();
-            expect(keys).toEqual(['key1', 'key3', 'key2']);
-        });
-        it('应该返回正确的值列表（按使用顺序）', () => {
-            const cache = new LruCache(3);
-            cache.set('key1', 'value1');
-            cache.set('key2', 'value2');
-            cache.set('key3', 'value3');
-            cache.get('key1'); // 使 key1 成为最近使用的
-            const values = cache.values();
-            expect(values).toEqual(['value1', 'value3', 'value2']);
-        });
-        it('应该返回正确的键值对列表（按使用顺序）', () => {
-            const cache = new LruCache(3);
-            cache.set('key1', 'value1');
-            cache.set('key2', 'value2');
-            cache.set('key3', 'value3');
-            cache.get('key1'); // 使 key1 成为最近使用的
-            const entries = cache.entries();
-            expect(entries).toEqual([
-                ['key1', 'value1'],
-                ['key3', 'value3'],
-                ['key2', 'value2']
-            ]);
-        });
-        it('应该在空缓存时返回空数组', () => {
-            const cache = new LruCache(3);
-            expect(cache.keys()).toEqual([]);
-            expect(cache.values()).toEqual([]);
-            expect(cache.entries()).toEqual([]);
-        });
-    });
-    describe('边界情况', () => {
-        it('应该处理容量为1的缓存', () => {
-            const cache = new LruCache(1);
-            cache.set('key1', 'value1');
-            expect(cache.get('key1')).toBe('value1');
-            cache.set('key2', 'value2');
-            expect(cache.has('key1')).toBe(false);
-            expect(cache.get('key2')).toBe('value2');
-            expect(cache.size).toBe(1);
-        });
-        it('应该处理大量的操作', () => {
-            const cache = new LruCache(100);
-            // 添加200个项目
-            for (let i = 0; i < 200; i++) {
-                cache.set(`key${i}`, i);
-            }
-            expect(cache.size).toBe(100);
-            // 前100个应该被移除
-            for (let i = 0; i < 100; i++) {
-                expect(cache.has(`key${i}`)).toBe(false);
-            }
-            // 后100个应该存在
-            for (let i = 100; i < 200; i++) {
-                expect(cache.has(`key${i}`)).toBe(true);
-                expect(cache.get(`key${i}`)).toBe(i);
-            }
-        });
-        it('应该处理复杂的对象类型', () => {
-            const cache = new LruCache(3);
-            const obj1 = { id: 1, name: 'test1', data: { count: 10 } };
-            const obj2 = { id: 2, name: 'test2', data: { count: 20 } };
-            cache.set('obj1', obj1);
-            cache.set('obj2', obj2);
-            expect(cache.get('obj1')).toEqual(obj1);
-            expect(cache.get('obj2')).toEqual(obj2);
-        });
-        it('应该处理null和undefined值', () => {
-            const cache = new LruCache(3);
-            cache.set('null', null);
-            cache.set('undefined', undefined);
-            expect(cache.get('null')).toBeNull();
-            expect(cache.get('undefined')).toBeUndefined();
-            expect(cache.has('null')).toBe(true);
-            expect(cache.has('undefined')).toBe(true);
-        });
-    });
-    describe('性能和内存', () => {
-        it('应该在删除后正确管理内存', () => {
-            const cache = new LruCache(3);
-            cache.set('key1', 'value1');
-            cache.set('key2', 'value2');
-            cache.set('key3', 'value3');
-            expect(cache.size).toBe(3);
-            cache.delete('key2');
-            expect(cache.size).toBe(2);
-            expect(cache.keys()).toEqual(['key3', 'key1']);
-        });
-        it('应该正确处理连续的相同键设置', () => {
-            const cache = new LruCache(2);
-            cache.set('key1', 'value1');
-            cache.set('key1', 'value1_updated');
-            cache.set('key1', 'value1_final');
-            expect(cache.size).toBe(1);
-            expect(cache.get('key1')).toBe('value1_final');
-        });
-    });
-    describe('实际使用场景', () => {
-        it('应该能用作函数结果缓存', () => {
-            const cache = new LruCache(3);
-            let computeCount = 0;
-            function expensiveCompute(n) {
-                const cacheKey = `compute_${n}`;
-                if (cache.has(cacheKey)) {
-                    return cache.get(cacheKey);
-                }
-                computeCount++;
-                const result = n * n; // 模拟昂贵的计算
-                cache.set(cacheKey, result);
-                return result;
-            }
-            // 第一次计算
-            expect(expensiveCompute(5)).toBe(25);
-            expect(computeCount).toBe(1);
-            // 缓存命中
-            expect(expensiveCompute(5)).toBe(25);
-            expect(computeCount).toBe(1);
-            // 新的计算
-            expect(expensiveCompute(6)).toBe(36);
-            expect(computeCount).toBe(2);
-        });
-        it('应该能用作API响应缓存', () => {
-            const cache = new LruCache(10);
-            const mockApiResponse = {
-                data: [{ id: 1, name: 'test' }],
-                timestamp: Date.now()
-            };
-            cache.set('/api/users', mockApiResponse);
-            const cachedResponse = cache.get('/api/users');
-            expect(cachedResponse).toEqual(mockApiResponse);
-            expect(cachedResponse?.data).toHaveLength(1);
-        });
-    });
-});

package/output/number/index.d.ts

@@ -1,2 +0,0 @@
-export * from './number.js';
-//# sourceMappingURL=index.d.ts.map

package/output/number/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/number/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/output/number/index.js

@@ -1 +0,0 @@
-export * from './number.js';

package/output/number/number.d.ts

@@ -1,2 +0,0 @@
-export declare function bigintToNumber(value: bigint | null): number;
-//# sourceMappingURL=number.d.ts.map

package/output/number/number.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../source/number/number.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAwB3D"}

package/output/number/number.js

@@ -1,23 +0,0 @@
-export function bigintToNumber(value) {
-    if (value === null)
-        return 0;
-    // JavaScript 的 number 类型最大值
-    const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER; // 2^53 - 1
-    const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER; // -(2^53 - 1)
-    try {
-        // 检查输入是否为 bigint
-        if (typeof value !== 'bigint') {
-            throw new TypeError('Input must be a bigint');
-        }
-        // 检查是否溢出
-        if (value > BigInt(MAX_SAFE_INTEGER) || value < BigInt(MIN_SAFE_INTEGER)) {
-            return MAX_SAFE_INTEGER; // 溢出，返回 NaN
-        }
-        // 将 bigint 转换为 number
-        return Number(value);
-    }
-    catch {
-        // 捕获任何错误并返回 NaN
-        return 0;
-    }
-}

package/output/number/number.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=number.test.d.ts.map

package/output/number/number.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"number.test.d.ts","sourceRoot":"","sources":["../../source/number/number.test.ts"],"names":[],"mappings":""}

package/output/number/number.test.js

@@ -1,50 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { bigintToNumber } from './number.js';
-describe('bigintToNumber 函数', () => {
-    it('应该将小的 bigint 转换为 number', () => {
-        const result = bigintToNumber(123n);
-        expect(result).toBe(123);
-    });
-    it('应该将负数 bigint 转换为 number', () => {
-        const result = bigintToNumber(-456n);
-        expect(result).toBe(-456);
-    });
-    it('应该将零 bigint 转换为 number', () => {
-        const result = bigintToNumber(0n);
-        expect(result).toBe(0);
-    });
-    it('应该为 null 输入返回 0', () => {
-        const result = bigintToNumber(null);
-        expect(result).toBe(0);
-    });
-    it('应该处理 MAX_SAFE_INTEGER 的 bigint', () => {
-        const maxSafe = BigInt(Number.MAX_SAFE_INTEGER);
-        const result = bigintToNumber(maxSafe);
-        expect(result).toBe(Number.MAX_SAFE_INTEGER);
-    });
-    it('应该处理 MIN_SAFE_INTEGER 的 bigint', () => {
-        const minSafe = BigInt(Number.MIN_SAFE_INTEGER);
-        const result = bigintToNumber(minSafe);
-        expect(result).toBe(Number.MIN_SAFE_INTEGER);
-    });
-    it('应该为 bigint 溢出（正数）返回 MAX_SAFE_INTEGER', () => {
-        const tooBig = BigInt(Number.MAX_SAFE_INTEGER) + 1n;
-        const result = bigintToNumber(tooBig);
-        expect(result).toBe(Number.MAX_SAFE_INTEGER);
-    });
-    it('应该为 bigint 溢出（负数）返回 MAX_SAFE_INTEGER', () => {
-        const tooSmall = BigInt(Number.MIN_SAFE_INTEGER) - 1n;
-        const result = bigintToNumber(tooSmall);
-        expect(result).toBe(Number.MAX_SAFE_INTEGER);
-    });
-    it('应该处理非常大的 bigint', () => {
-        const veryLarge = 999999999999999999999n;
-        const result = bigintToNumber(veryLarge);
-        expect(result).toBe(Number.MAX_SAFE_INTEGER);
-    });
-    it('应该处理从 number 创建的 bigint', () => {
-        const bigintFromNumber = BigInt(42);
-        const result = bigintToNumber(bigintFromNumber);
-        expect(result).toBe(42);
-    });
-});

package/output/object/index.d.ts

@@ -1,2 +0,0 @@
-export * from './object.js';
-//# sourceMappingURL=index.d.ts.map

package/output/object/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/object/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}

package/output/object/index.js

@@ -1 +0,0 @@
-export * from './object.js';

package/output/object/object.d.ts

@@ -1,7 +0,0 @@
-/**
- * 递归合并对象，只针对对象类型的属性进行合并，其他类型后者覆盖前者
- */
-export declare function objectMerge<T extends object>(target: T, ...rest: Partial<T>[]): T;
-export declare function ObjectKeys<T extends object>(obj: T): (keyof T)[];
-export declare function ObjectValues<T extends object>(obj: T): T[keyof T][];
-//# sourceMappingURL=object.d.ts.map

package/output/object/object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../source/object/object.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAiBjF;AAED,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,CAEhE;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAEnE"}

package/output/object/object.js

@@ -1,27 +0,0 @@
-/**
- * 递归合并对象，只针对对象类型的属性进行合并，其他类型后者覆盖前者
- */
-export function objectMerge(target, ...rest) {
-    for (const source of rest) {
-        for (const key in source) {
-            if (source.hasOwnProperty(key)) {
-                if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
-                    if (!target.hasOwnProperty(key)) {
-                        target[key] = {};
-                    }
-                    objectMerge(target[key], source[key]);
-                }
-                else {
-                    target[key] = source[key];
-                }
-            }
-        }
-    }
-    return target;
-}
-export function ObjectKeys(obj) {
-    return Object.keys(obj);
-}
-export function ObjectValues(obj) {
-    return Object.values(obj);
-}

package/output/object/object.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=object.test.d.ts.map

package/output/object/object.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"object.test.d.ts","sourceRoot":"","sources":["../../source/object/object.test.ts"],"names":[],"mappings":""}

package/output/object/object.test.js

@@ -1,42 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { objectMerge } from './object.js';
-describe('merge 函数', () => {
-    it('应该合并两个简单对象', () => {
-        const target = { a: 1 };
-        const source = { b: 2 };
-        const result = objectMerge(target, source);
-        expect(result).toEqual({ a: 1, b: 2 });
-    });
-    it('应该合并嵌套对象', () => {
-        const target = { a: 1, b: { c: 2 } };
-        const source = { b: { d: 3 }, e: 4 };
-        const result = objectMerge(target, source);
-        expect(result).toEqual({ a: 1, b: { c: 2, d: 3 }, e: 4 });
-    });
-    it('应该合并多个对象', () => {
-        const target = { a: 1 };
-        const source1 = { b: 2 };
-        const source2 = { c: 3 };
-        const result = objectMerge(target, source1, source2);
-        expect(result).toEqual({ a: 1, b: 2, c: 3 });
-    });
-    it('应该覆盖现有属性', () => {
-        const target = { a: 1, b: 2 };
-        const source = { b: 3, c: 4 };
-        const result = objectMerge(target, source);
-        expect(result).toEqual({ a: 1, b: 3, c: 4 });
-    });
-    it('应该处理 null 和数组值', () => {
-        const target = { a: 1, b: null };
-        const source = { b: [1, 2, 3], c: 4 };
-        const result = objectMerge(target, source);
-        expect(result).toEqual({ a: 1, b: [1, 2, 3], c: 4 });
-    });
-    it('应该不改变原始目标对象', () => {
-        const target = { a: 1 };
-        const source = { b: 2 };
-        const result = objectMerge(target, source);
-        expect(result).toEqual({ a: 1, b: 2 });
-        expect(source).toEqual({ b: 2 }); // Target should remain unchanged
-    });
-});

package/output/ring-cache/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Ring Cache 模块
- * 专门用于日志场景的FIFO环形缓存
- */
-export * from './ring-cache.js';
-//# sourceMappingURL=index.d.ts.map

package/output/ring-cache/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/ring-cache/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,iBAAiB,CAAA"}

package/output/ring-cache/index.js

@@ -1,5 +0,0 @@
-/**
- * Ring Cache 模块
- * 专门用于日志场景的FIFO环形缓存
- */
-export * from './ring-cache.js';

package/output/ring-cache/ring-cache.d.ts

@@ -1,125 +0,0 @@
-/**
- * 环形缓存（Ring Cache）实现
- * 专门用于日志场景的FIFO（先进先出）缓存
- *
- * 特点：
- * - FIFO行为：新数据总是添加到尾部，当容量满时从头部移除旧数据
- * - 固定容量：避免内存无限增长
- * - 高效操作：O(1)的添加和访问操作
- * - 适用场景：日志记录、事件历史、时间序列数据等
- */
-/**
- * 环形缓存配置选项
- */
-export interface RingCacheOptions {
-    /** 缓存容量，默认为1000 */
-    capacity?: number;
-}
-/**
- * 环形缓存条目
- */
-export interface RingCacheEntry<T> {
-    /** 数据 */
-    data: T;
-    /** 添加时间戳 */
-    timestamp: Date;
-    /** 条目ID */
-    id: string;
-}
-/**
- * 环形缓存统计信息
- */
-export interface RingCacheStats {
-    /** 当前条目数量 */
-    size: number;
-    /** 缓存容量 */
-    capacity: number;
-    /** 是否已满 */
-    isFull: boolean;
-    /** 最旧条目的时间戳 */
-    oldestTimestamp?: Date;
-    /** 最新条目的时间戳 */
-    newestTimestamp?: Date;
-    /** 总共添加的条目数（包括已被覆盖的） */
-    totalAdded: number;
-}
-/**
- * 环形缓存实现
- * 使用固定大小的数组实现FIFO行为的环形缓存
- */
-export declare class RingCache<T> {
-    private buffer;
-    private head;
-    private tail;
-    private size;
-    private capacity;
-    private totalAdded;
-    private nextId;
-    constructor(options?: RingCacheOptions);
-    /**
-     * 添加新条目到缓存
-     * 如果缓存已满，将覆盖最旧的条目
-     */
-    add(data: T): RingCacheEntry<T>;
-    /**
-     * 获取所有缓存条目（按添加顺序）
-     */
-    getAll(): RingCacheEntry<T>[];
-    /**
-     * 获取最近的N个条目
-     */
-    getRecent(count: number): RingCacheEntry<T>[];
-    /**
-     * 获取最旧的N个条目
-     */
-    getOldest(count: number): RingCacheEntry<T>[];
-    /**
-     * 根据时间范围获取条目
-     */
-    getByTimeRange(start: Date, end: Date): RingCacheEntry<T>[];
-    /**
-     * 搜索满足条件的条目
-     */
-    search(predicate: (entry: RingCacheEntry<T>) => boolean): RingCacheEntry<T>[];
-    /**
-     * 获取缓存统计信息
-     */
-    getStats(): RingCacheStats;
-    /**
-     * 检查缓存是否为空
-     */
-    isEmpty(): boolean;
-    /**
-     * 检查缓存是否已满
-     */
-    isFull(): boolean;
-    /**
-     * 获取当前缓存大小
-     */
-    getSize(): number;
-    /**
-     * 获取缓存容量
-     */
-    getCapacity(): number;
-    /**
-     * 清空缓存
-     */
-    clear(): void;
-    /**
-     * 导出为数组格式
-     */
-    toArray(): T[];
-    /**
-     * 导出为JSON格式
-     */
-    toJSON(): string;
-    /**
-     * 生成唯一ID
-     */
-    private generateId;
-    /**
-     * 创建迭代器，支持for...of语法
-     */
-    [Symbol.iterator](): Iterator<RingCacheEntry<T>>;
-}
-//# sourceMappingURL=ring-cache.d.ts.map

package/output/ring-cache/ring-cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ring-cache.d.ts","sourceRoot":"","sources":["../../source/ring-cache/ring-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mBAAmB;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,SAAS;IACT,IAAI,EAAE,CAAC,CAAA;IACP,YAAY;IACZ,SAAS,EAAE,IAAI,CAAA;IACf,WAAW;IACX,EAAE,EAAE,MAAM,CAAA;CACX;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,aAAa;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW;IACX,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW;IACX,MAAM,EAAE,OAAO,CAAA;IACf,eAAe;IACf,eAAe,CAAC,EAAE,IAAI,CAAA;IACtB,eAAe;IACf,eAAe,CAAC,EAAE,IAAI,CAAA;IACtB,wBAAwB;IACxB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;;GAGG;AACH,qBAAa,SAAS,CAAC,CAAC;IACtB,OAAO,CAAC,MAAM,CAAmC;IACjD,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,IAAI,CAAY;IACxB,OAAO,CAAC,QAAQ,CAAQ;IACxB,OAAO,CAAC,UAAU,CAAY;IAC9B,OAAO,CAAC,MAAM,CAAY;gBAEd,OAAO,GAAE,gBAAqB;IAQ1C;;;OAGG;IACH,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC;IAqB/B;;OAEG;IACH,MAAM,IAAI,cAAc,CAAC,CAAC,CAAC,EAAE;IAkB7B;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE;IAoB7C;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE;IAmB7C;;OAEG;IACH,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE;IAM3D;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE;IAI7E;;OAEG;IACH,QAAQ,IAAI,cAAc;IAa1B;;OAEG;IACH,OAAO,IAAI,OAAO;IAIlB;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;OAEG;IACH,OAAO,IAAI,MAAM;IAIjB;;OAEG;IACH,WAAW,IAAI,MAAM;IAIrB;;OAEG;IACH,KAAK,IAAI,IAAI;IASb;;OAEG;IACH,OAAO,IAAI,CAAC,EAAE;IAId;;OAEG;IACH,MAAM,IAAI,MAAM;IAIhB;;OAEG;IACH,OAAO,CAAC,UAAU;IAIlB;;OAEG;IACF,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CASlD"}