xxf_react 0.6.6 → 0.6.8

package/dist/http/cache/DiskLruCache.js

@@ -0,0 +1,254 @@
+/**
+ * 基于 IndexedDB 的 LRU 磁盘缓存
+ *
+ * 特点：
+ * - 使用 idb-keyval 简化 IndexedDB 操作
+ * - 维护 LRU 元数据实现淘汰策略
+ * - 支持 TTL 过期
+ * - 批量清理优化性能
+ * - 防污染：返回数据的深拷贝
+ */
+import { get, set, del, clear as clearStore, createStore } from 'idb-keyval';
+const META_KEY = '__lru_metadata__';
+export class DiskLruCache {
+    constructor(config) {
+        this.metadata = null;
+        this.metadataDirty = false;
+        this.flushTimer = null;
+        this.evicting = false; // 防止并发淘汰
+        this.config = {
+            cleanupThreshold: 0.1,
+            ...config,
+        };
+        this.store = createStore(config.dbName, config.storeName);
+    }
+    /**
+     * 加载或初始化 LRU 元数据（失败返回空元数据）
+     */
+    async loadMetadata() {
+        if (this.metadata)
+            return this.metadata;
+        try {
+            const stored = await get(META_KEY, this.store);
+            if (stored) {
+                this.metadata = stored;
+            }
+            else {
+                this.metadata = { entries: {}, count: 0 };
+            }
+        }
+        catch {
+            // 加载失败，使用空元数据
+            this.metadata = { entries: {}, count: 0 };
+        }
+        return this.metadata;
+    }
+    /**
+     * 保存元数据到磁盘 (批量优化，延迟写入)
+     */
+    scheduleFlushMetadata() {
+        if (this.flushTimer)
+            return;
+        this.metadataDirty = true;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            if (this.metadataDirty && this.metadata) {
+                set(META_KEY, this.metadata, this.store)
+                    .then(() => {
+                    this.metadataDirty = false;
+                })
+                    .catch(() => {
+                    // 静默处理写入错误，下次会重试
+                });
+            }
+        }, 1000); // 1 秒后批量写入
+    }
+    /**
+     * 立即刷新元数据到磁盘（失败静默忽略）
+     */
+    async flush() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        if (this.metadataDirty && this.metadata) {
+            try {
+                await set(META_KEY, this.metadata, this.store);
+                this.metadataDirty = false;
+            }
+            catch {
+                // 刷新失败静默忽略，下次会重试
+            }
+        }
+    }
+    /**
+     * 获取缓存（失败返回 null，不影响业务）
+     * @returns 缓存条目的深拷贝
+     */
+    async get(key) {
+        try {
+            const meta = await this.loadMetadata();
+            // 检查是否存在
+            if (!meta.entries[key]) {
+                return null;
+            }
+            const entry = await get(key, this.store);
+            if (!entry) {
+                // 数据丢失，清理元数据
+                delete meta.entries[key];
+                meta.count = Math.max(0, meta.count - 1);
+                this.scheduleFlushMetadata();
+                return null;
+            }
+            // 检查是否过期
+            if (entry.ttl > 0 && Date.now() - entry.timestamp > entry.ttl) {
+                await this.delete(key);
+                return null;
+            }
+            // 更新访问时间
+            meta.entries[key] = { accessTime: Date.now() };
+            this.scheduleFlushMetadata();
+            return entry;
+        }
+        catch {
+            // IndexedDB 操作失败，返回 null 不影响业务
+            return null;
+        }
+    }
+    /**
+     * 设置缓存（失败静默忽略，不影响业务）
+     */
+    async set(key, data, ttl = 0) {
+        try {
+            const meta = await this.loadMetadata();
+            const entry = {
+                data,
+                timestamp: Date.now(),
+                ttl,
+                key,
+            };
+            // 检查是否需要淘汰
+            if (!meta.entries[key] && meta.count >= this.config.maxSize) {
+                await this.evict();
+            }
+            await set(key, entry, this.store);
+            // 更新元数据
+            if (!meta.entries[key]) {
+                meta.count++;
+            }
+            meta.entries[key] = { accessTime: Date.now() };
+            this.scheduleFlushMetadata();
+        }
+        catch {
+            // IndexedDB 操作失败，静默忽略不影响业务
+        }
+    }
+    /**
+     * 删除缓存（失败静默忽略）
+     */
+    async delete(key) {
+        try {
+            const meta = await this.loadMetadata();
+            if (meta.entries[key]) {
+                await del(key, this.store);
+                delete meta.entries[key];
+                meta.count = Math.max(0, meta.count - 1);
+                this.scheduleFlushMetadata();
+            }
+        }
+        catch {
+            // 删除失败静默忽略
+        }
+    }
+    /**
+     * 检查缓存是否存在（不更新访问时间，失败返回 false）
+     */
+    async has(key) {
+        try {
+            const meta = await this.loadMetadata();
+            return !!meta.entries[key];
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 淘汰最旧的缓存条目（失败静默忽略）
+     */
+    async evict() {
+        // 防止并发淘汰
+        if (this.evicting)
+            return;
+        this.evicting = true;
+        try {
+            const meta = await this.loadMetadata();
+            // 计算需要淘汰的数量
+            const evictCount = Math.ceil(this.config.maxSize * this.config.cleanupThreshold);
+            // 按访问时间排序
+            const sorted = Object.entries(meta.entries).sort((a, b) => a[1].accessTime - b[1].accessTime);
+            // 淘汰最旧的
+            const toEvict = sorted.slice(0, evictCount);
+            for (const [key] of toEvict) {
+                try {
+                    await del(key, this.store);
+                }
+                catch {
+                    // 单个删除失败继续处理其他
+                }
+                delete meta.entries[key];
+                meta.count = Math.max(0, meta.count - 1);
+            }
+            this.scheduleFlushMetadata();
+        }
+        catch {
+            // 淘汰失败静默忽略
+        }
+        finally {
+            this.evicting = false;
+        }
+    }
+    /**
+     * 清空所有缓存（失败静默忽略）
+     */
+    async clear() {
+        // 取消待处理的元数据写入
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        try {
+            // 使用 idb-keyval 的 clear 方法一次性清空整个 store
+            await clearStore(this.store);
+        }
+        catch {
+            // 清空失败静默忽略
+        }
+        // 重置内存中的元数据
+        this.metadata = { entries: {}, count: 0 };
+        this.metadataDirty = false;
+    }
+    /**
+     * 获取缓存数量（失败返回 0）
+     */
+    async size() {
+        try {
+            const meta = await this.loadMetadata();
+            return meta.count;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * 获取所有缓存 key（失败返回空数组）
+     */
+    async keys() {
+        try {
+            const meta = await this.loadMetadata();
+            return Object.keys(meta.entries);
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/dist/http/cache/HttpCache.d.ts

@@ -0,0 +1,59 @@
+/**
+ * HTTP 缓存（内存 + 磁盘双层）
+ *
+ * 策略：
+ * - 读取：先内存 -> 再磁盘 -> 若磁盘命中则回填内存
+ * - 写入：同时写入内存和磁盘
+ * - 容错：缓存操作失败不影响正常业务
+ * - 防污染：返回数据的深拷贝，防止上层修改影响缓存
+ */
+import { DiskLruCache } from './DiskLruCache';
+import type { CacheEntry, HttpCacheConfig } from '../types';
+export declare class HttpCache {
+    private memoryCache;
+    private diskCache;
+    constructor(config: HttpCacheConfig);
+    /**
+     * 获取缓存
+     * @param key 缓存 key
+     * @returns 缓存条目的深拷贝，未命中或失败返回 null
+     */
+    get<T>(key: string): Promise<CacheEntry<T> | null>;
+    /**
+     * 设置缓存（失败静默忽略，不影响业务）
+     * @param key 缓存 key
+     * @param data 数据
+     * @param ttl 过期时间 (ms)
+     */
+    set<T>(key: string, data: T, ttl?: number): Promise<void>;
+    /**
+     * 删除缓存（失败静默忽略）
+     */
+    delete(key: string): Promise<void>;
+    /**
+     * 清空所有缓存（失败静默忽略）
+     */
+    clear(): Promise<void>;
+    /**
+     * 仅获取内存缓存（同步，失败返回 null）
+     * @returns 缓存条目的深拷贝
+     */
+    getFromMemory<T>(key: string): CacheEntry<T> | null;
+    /**
+     * 仅设置内存缓存（同步，失败静默忽略）
+     */
+    setToMemory<T>(key: string, data: T, ttl?: number): void;
+    /**
+     * 检查缓存是否存在（会检查过期，失败返回 false）
+     */
+    has(key: string): Promise<boolean>;
+    /**
+     * 获取磁盘缓存实例（用于高级操作）
+     */
+    getDiskCache(): DiskLruCache;
+    /**
+     * 刷新磁盘缓存元数据（失败静默忽略）
+     */
+    flush(): Promise<void>;
+}
+//# sourceMappingURL=HttpCache.d.ts.map

package/dist/http/cache/HttpCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpCache.d.ts","sourceRoot":"","sources":["../../../src/http/cache/HttpCache.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAG3D,qBAAa,SAAS;IAClB,OAAO,CAAC,WAAW,CAAiB;IACpC,OAAO,CAAC,SAAS,CAAc;gBAEnB,MAAM,EAAE,eAAe;IAcnC;;;;OAIG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAwCxD;;;;;OAKG;IACG,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,GAAE,MAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBlE;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcxC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAc5B;;;OAGG;IACH,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI;IAgBnD;;OAEG;IACH,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,GAAE,MAAU,GAAG,IAAI;IAc3D;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAyBxC;;OAEG;IACH,YAAY,IAAI,YAAY;IAI5B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAO/B"}

package/dist/http/cache/HttpCache.js

@@ -0,0 +1,215 @@
+/**
+ * HTTP 缓存（内存 + 磁盘双层）
+ *
+ * 策略：
+ * - 读取：先内存 -> 再磁盘 -> 若磁盘命中则回填内存
+ * - 写入：同时写入内存和磁盘
+ * - 容错：缓存操作失败不影响正常业务
+ * - 防污染：返回数据的深拷贝，防止上层修改影响缓存
+ */
+import { lru } from 'tiny-lru';
+import { DiskLruCache } from './DiskLruCache';
+import { copy } from '../../foundation';
+export class HttpCache {
+    constructor(config) {
+        // 初始化内存缓存
+        // 注意：不使用 tiny-lru 的 ttl 参数，因为每个 entry 有自己的 ttl
+        // tiny-lru 的 ttl 是全局的，会导致冲突
+        this.memoryCache = lru(config.memoryMaxSize);
+        // 初始化磁盘缓存
+        this.diskCache = new DiskLruCache({
+            dbName: config.dbName,
+            storeName: 'http-cache',
+            maxSize: config.diskMaxSize,
+        });
+    }
+    /**
+     * 获取缓存
+     * @param key 缓存 key
+     * @returns 缓存条目的深拷贝，未命中或失败返回 null
+     */
+    async get(key) {
+        // 1. 先查内存（内存操作用 try-catch 保护）
+        try {
+            const memEntry = this.memoryCache.get(key);
+            if (memEntry) {
+                // 检查是否过期
+                if (memEntry.ttl > 0 &&
+                    Date.now() - memEntry.timestamp > memEntry.ttl) {
+                    this.memoryCache.delete(key);
+                }
+                else {
+                    // 返回深拷贝，防止上层修改污染缓存
+                    return copy(memEntry);
+                }
+            }
+        }
+        catch {
+            // 内存缓存读取失败，继续尝试磁盘
+        }
+        // 2. 再查磁盘（磁盘操作失败返回 null，不影响业务）
+        try {
+            const diskEntry = await this.diskCache.get(key);
+            if (diskEntry) {
+                // 回填内存缓存（失败也忽略）
+                try {
+                    this.memoryCache.set(key, diskEntry);
+                }
+                catch {
+                    // 回填失败忽略
+                }
+                // 返回深拷贝，防止上层修改污染缓存
+                return copy(diskEntry);
+            }
+        }
+        catch {
+            // 磁盘缓存读取失败，返回 null
+        }
+        return null;
+    }
+    /**
+     * 设置缓存（失败静默忽略，不影响业务）
+     * @param key 缓存 key
+     * @param data 数据
+     * @param ttl 过期时间 (ms)
+     */
+    async set(key, data, ttl = 0) {
+        const entry = {
+            data,
+            timestamp: Date.now(),
+            ttl,
+            key,
+        };
+        // 写入内存（失败忽略）
+        try {
+            this.memoryCache.set(key, entry);
+        }
+        catch {
+            // 内存写入失败忽略
+        }
+        // 写入磁盘（失败忽略）
+        try {
+            await this.diskCache.set(key, data, ttl);
+        }
+        catch {
+            // 磁盘写入失败忽略，不影响业务
+        }
+    }
+    /**
+     * 删除缓存（失败静默忽略）
+     */
+    async delete(key) {
+        try {
+            this.memoryCache.delete(key);
+        }
+        catch {
+            // 忽略
+        }
+        try {
+            await this.diskCache.delete(key);
+        }
+        catch {
+            // 忽略
+        }
+    }
+    /**
+     * 清空所有缓存（失败静默忽略）
+     */
+    async clear() {
+        try {
+            this.memoryCache.clear();
+        }
+        catch {
+            // 忽略
+        }
+        try {
+            await this.diskCache.clear();
+        }
+        catch {
+            // 忽略
+        }
+    }
+    /**
+     * 仅获取内存缓存（同步，失败返回 null）
+     * @returns 缓存条目的深拷贝
+     */
+    getFromMemory(key) {
+        try {
+            const entry = this.memoryCache.get(key);
+            if (!entry)
+                return null;
+            if (entry.ttl > 0 && Date.now() - entry.timestamp > entry.ttl) {
+                this.memoryCache.delete(key);
+                return null;
+            }
+            // 返回深拷贝，防止上层修改污染缓存
+            return copy(entry);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 仅设置内存缓存（同步，失败静默忽略）
+     */
+    setToMemory(key, data, ttl = 0) {
+        try {
+            const entry = {
+                data,
+                timestamp: Date.now(),
+                ttl,
+                key,
+            };
+            this.memoryCache.set(key, entry);
+        }
+        catch {
+            // 忽略
+        }
+    }
+    /**
+     * 检查缓存是否存在（会检查过期，失败返回 false）
+     */
+    async has(key) {
+        // 先查内存
+        try {
+            const memEntry = this.memoryCache.get(key);
+            if (memEntry) {
+                // 检查是否过期
+                if (memEntry.ttl > 0 && Date.now() - memEntry.timestamp > memEntry.ttl) {
+                    this.memoryCache.delete(key);
+                }
+                else {
+                    return true;
+                }
+            }
+        }
+        catch {
+            // 内存检查失败，继续检查磁盘
+        }
+        // 再查磁盘
+        try {
+            const diskEntry = await this.diskCache.get(key);
+            return diskEntry !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 获取磁盘缓存实例（用于高级操作）
+     */
+    getDiskCache() {
+        return this.diskCache;
+    }
+    /**
+     * 刷新磁盘缓存元数据（失败静默忽略）
+     */
+    async flush() {
+        try {
+            await this.diskCache.flush();
+        }
+        catch {
+            // 忽略
+        }
+    }
+}

package/dist/http/cache/index.d.ts

@@ -0,0 +1,3 @@
+export { DiskLruCache } from './DiskLruCache';
+export { HttpCache } from './HttpCache';
+//# sourceMappingURL=index.d.ts.map

package/dist/http/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/http/cache/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA"}

package/dist/http/cache/index.js

@@ -0,0 +1,2 @@
+export { DiskLruCache } from './DiskLruCache';
+export { HttpCache } from './HttpCache';

package/dist/http/client/ApiStream.d.ts

@@ -0,0 +1,80 @@
+/**
+ * ApiStream - AsyncGenerator 流式响应
+ *
+ * 支持三种消费方式：
+ * 1. await - 直接获取最后一个结果
+ * 2. for await - 迭代所有结果
+ * 3. subscribe - 安全消费（框架 try-catch）
+ */
+import type { ApiResult, ApiCallback } from '../types';
+export declare class ApiStream<T> implements AsyncIterable<ApiResult<T>>, PromiseLike<T> {
+    private generator;
+    private consumed;
+    constructor(generator: () => AsyncGenerator<ApiResult<T>>);
+    /**
+     * 实现 AsyncIterable，支持 for await
+     *
+     * 注意：每次迭代都会创建新的请求。如果需要缓存结果，请使用 toArray()
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<ApiResult<T>>;
+    /**
+     * 实现 PromiseLike，支持直接 await（返回最后一个结果的 data）
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    /**
+     * 实现 catch
+     */
+    catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    /**
+     * 实现 finally
+     */
+    finally(onfinally?: (() => void) | null): Promise<T>;
+    /**
+     * 获取第一个结果
+     * @throws 如果没有结果会抛出错误
+     */
+    first(): Promise<ApiResult<T>>;
+    /**
+     * 获取第一个结果，没有则返回 null
+     */
+    firstOrNull(): Promise<ApiResult<T> | null>;
+    /**
+     * 获取最后一个结果
+     * @throws 如果没有结果会抛出错误
+     */
+    last(): Promise<ApiResult<T>>;
+    /**
+     * 获取最后一个结果，没有则返回 null
+     */
+    lastOrNull(): Promise<ApiResult<T> | null>;
+    /**
+     * 获取所有结果
+     */
+    toArray(): Promise<ApiResult<T>[]>;
+    /**
+     * 查找满足条件的第一个结果
+     */
+    find(predicate: (result: ApiResult<T>) => boolean): Promise<ApiResult<T> | undefined>;
+    /**
+     * 安全消费（框架 try-catch 隔离错误）
+     * onData 抛错不会影响后续 yield
+     */
+    subscribe(callback: ApiCallback<T>): Promise<void>;
+    /**
+     * 映射结果
+     */
+    map<U>(fn: (data: T) => U): ApiStream<U>;
+    /**
+     * 过滤结果
+     */
+    filter(predicate: (result: ApiResult<T>) => boolean): ApiStream<T>;
+    /**
+     * 只获取缓存结果
+     */
+    cacheOnly(): ApiStream<T>;
+    /**
+     * 只获取网络结果
+     */
+    remoteOnly(): ApiStream<T>;
+}
+//# sourceMappingURL=ApiStream.d.ts.map

package/dist/http/client/ApiStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApiStream.d.ts","sourceRoot":"","sources":["../../../src/http/client/ApiStream.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtD,qBAAa,SAAS,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;IAC5E,OAAO,CAAC,SAAS,CAAoC;IACrD,OAAO,CAAC,QAAQ,CAAQ;gBAEZ,SAAS,EAAE,MAAM,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAIzD;;;;OAIG;IACH,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAqBtD;;OAEG;IACH,IAAI,CAAC,QAAQ,GAAG,CAAC,EAAE,QAAQ,GAAG,KAAK,EAC/B,WAAW,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,KAAK,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,EACrE,UAAU,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,KAAK,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,GAC5E,OAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAM/B;;OAEG;IACH,KAAK,CAAC,OAAO,GAAG,KAAK,EACjB,UAAU,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,GAC1E,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC;IAIvB;;OAEG;IACH,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC;IAapD;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAQpC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAOjD;;;OAGG;IACG,IAAI,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAQnC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAQhD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IAQxC;;OAEG;IACG,IAAI,CACN,SAAS,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,OAAO,GAC7C,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IASpC;;;OAGG;IACG,SAAS,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBxD;;OAEG;IACH,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;IAYxC;;OAEG;IACH,MAAM,CAAC,SAAS,EAAE,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC;IAWlE;;OAEG;IACH,SAAS,IAAI,SAAS,CAAC,CAAC,CAAC;IAIzB;;OAEG;IACH,UAAU,IAAI,SAAS,CAAC,CAAC,CAAC;CAG7B"}