@kikiutils/shared 9.2.0 → 9.3.1

package/dist/storage/enhanced/local/keyed-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyed-store.d.ts","sourceRoot":"","sources":["../../../../src/storage/enhanced/local/keyed-store.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,GAAG,OAAO,MAC7C,CAAC,SAAS,GAAG,EAAE,EAAE,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,MAAM;uBACxC,CAAC;uBACD,CAAC;0BACE,CAAC;IACvB;;;;OAIG;0BACmB,CAAC;qBACN,CAAC,WAAW,CAAC;GAErC"}

package/dist/storage/enhanced/local/keyed-store.mjs

@@ -0,0 +1,37 @@
+import { enhancedLocalStorage } from './core.mjs';
+
+/**
+ * Creates a reusable, type-safe storage interface based on `enhancedLocalStorage`
+ * and a dynamic key-generation function.
+ *
+ * This utility allows you to abstract away key construction logic and work directly
+ * with scoped key-value operations like `getItem`, `setItem`, and `removeItem`.
+ *
+ * @template D - The value type to store.
+ *
+ * @returns A factory that accepts a key generator function and returns a scoped storage interface.
+ *
+ * @example
+ * ```typescript
+ * const userStore = createKeyedEnhancedLocalStore<User>()((id: number) => `user:${id}`);
+ * userStore.setItem({ id: 123, name: 'user' }, 123);
+ * const user = userStore.getItem(123);
+ * ```
+ */
+function createKeyedEnhancedLocalStore() {
+    return (getKeyFunction) => Object.freeze({
+        getItem: (...args) => enhancedLocalStorage.getItem(getKeyFunction(...args)),
+        hasItem: (...args) => enhancedLocalStorage.hasItem(getKeyFunction(...args)),
+        removeItem: (...args) => enhancedLocalStorage.removeItem(getKeyFunction(...args)),
+        /**
+         * Resolves the storage key from the given arguments.
+         *
+         * @returns {string} The final string key used internally.
+         */
+        resolveKey: (...args) => getKeyFunction(...args),
+        setItem: (value, ...args) => enhancedLocalStorage.setItem(getKeyFunction(...args), value),
+    });
+}
+
+export { createKeyedEnhancedLocalStore };
+//# sourceMappingURL=keyed-store.mjs.map

package/dist/storage/enhanced/local/keyed-store.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyed-store.mjs","sources":["../../../../src/storage/enhanced/local/keyed-store.ts"],"sourcesContent":["import { enhancedLocalStorage } from './core';\n\n/**\n * Creates a reusable, type-safe storage interface based on `enhancedLocalStorage`\n * and a dynamic key-generation function.\n *\n * This utility allows you to abstract away key construction logic and work directly\n * with scoped key-value operations like `getItem`, `setItem`, and `removeItem`.\n *\n * @template D - The value type to store.\n *\n * @returns A factory that accepts a key generator function and returns a scoped storage interface.\n *\n * @example\n * ```typescript\n * const userStore = createKeyedEnhancedLocalStore<User>()((id: number) => `user:${id}`);\n * userStore.setItem({ id: 123, name: 'user' }, 123);\n * const user = userStore.getItem(123);\n * ```\n */\nexport function createKeyedEnhancedLocalStore<D = unknown>() {\n    return <P extends any[]>(getKeyFunction: (...args: P) => string) => Object.freeze({\n        getItem: (...args: P) => enhancedLocalStorage.getItem<D>(getKeyFunction(...args)),\n        hasItem: (...args: P) => enhancedLocalStorage.hasItem(getKeyFunction(...args)),\n        removeItem: (...args: P) => enhancedLocalStorage.removeItem(getKeyFunction(...args)),\n        /**\n         * Resolves the storage key from the given arguments.\n         *\n         * @returns {string} The final string key used internally.\n         */\n        resolveKey: (...args: P) => getKeyFunction(...args),\n        setItem: (value: D, ...args: P) => enhancedLocalStorage.setItem(getKeyFunction(...args), value),\n    });\n}\n"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;AAiBG;SACa,6BAA6B,GAAA;IACzC,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,oBAAoB,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjF,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,oBAAoB,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AAC9E,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,oBAAoB,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpF;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,oBAAoB,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClG,KAAA,CAAC;AACN;;;;"}

package/dist/storage/enhanced/redis/core.cjs

@@ -0,0 +1,142 @@
+'use strict';
+
+const node_buffer = require('node:buffer');
+const ioredis = require('ioredis');
+const superjson = require('superjson');
+
+var StorageValueEncodingType;
+(function (StorageValueEncodingType) {
+    StorageValueEncodingType[StorageValueEncodingType["Buffer"] = 0] = "Buffer";
+    StorageValueEncodingType[StorageValueEncodingType["Json"] = 1] = "Json";
+    StorageValueEncodingType[StorageValueEncodingType["String"] = 2] = "String";
+})(StorageValueEncodingType || (StorageValueEncodingType = {}));
+const customValueHeader = node_buffer.Buffer.of(0xE2, 0x81, 0xA0);
+const customValueHeaderLength = customValueHeader.byteLength + 1;
+/**
+ * Creates an enhanced Redis-based storage interface using SuperJSON encoding.
+ *
+ * This utility provides a typed, serializable key-value store backed by Redis,
+ * supporting TTL operations and safe deserialization of complex types (e.g. Date, Map).
+ *
+ * @param {Redis | string} ioRedisInstanceOrUrl - Either an existing `ioredis` instance or a Redis connection string.
+ *
+ * @returns A frozen object that wraps Redis commands with typed get/set logic and encoding.
+ *
+ * @example
+ * ```typescript
+ * const redisStorage = createEnhancedRedisStorage('redis://localhost');
+ * await redisStorage.setItem('user:1', { name: 'user' });
+ * const user = await redisStorage.getItem<{ name: string }>('user:1');
+ * ```
+ */
+function createEnhancedRedisStorage(ioRedisInstanceOrUrl) {
+    const instance = ioRedisInstanceOrUrl instanceof ioredis.Redis ? ioRedisInstanceOrUrl : new ioredis.Redis(ioRedisInstanceOrUrl);
+    return Object.freeze({
+        /**
+         * Retrieves a value from Redis and decodes it.
+         *
+         * @template T - The expected return type.
+         *
+         * @param {string} key - The Redis key.
+         *
+         * @returns {Promise<null | T>} The decoded value or null if not found.
+         */
+        async getItem(key) {
+            const rawValue = await instance.getBuffer(key);
+            return rawValue ? decodeStorageValue(rawValue) : null;
+        },
+        /**
+         * Gets the remaining TTL (in seconds) for a given key.
+         *
+         * @param {string} key - The Redis key.
+         *
+         * @returns {Promise<number>} The number of seconds until the key expires, or -1 if no expiration is set.
+         */
+        getItemTtl: (key) => instance.ttl(key),
+        /**
+         * Checks whether a key exists in Redis.
+         *
+         * @param {string} key - The Redis key.
+         *
+         * @returns {Promise<boolean>} True if the key exists, false otherwise.
+         */
+        hasItem: async (key) => await instance.exists(key) === 1,
+        /**
+         * The underlying Redis instance, exposed for advanced operations.
+         * Use with caution; most use cases should rely on the wrapper methods.
+         *
+         * @returns {Redis} The underlying Redis instance.
+         */
+        get instance() {
+            return instance;
+        },
+        /**
+         * Removes a key from Redis.
+         *
+         * @param {string} key - The Redis key to delete.
+         *
+         * @returns {Promise<boolean>} A Promise that resolves to `true` if the key was removed,
+         * or `false` if it did not exist.
+         */
+        removeItem: async (key) => await instance.del(key) === 1,
+        /**
+         * Stores a value in Redis without expiration.
+         *
+         * @param {string} key - The Redis key.
+         * @param {any} value - The value to store. Will be serialized.
+         */
+        setItem: (key, value) => instance.set(key, encodeToStorageValue(value)),
+        /**
+         * Stores a value in Redis with a time-to-live (TTL).
+         *
+         * @param {string} key - The Redis key.
+         * @param {number} seconds - Expiration time in seconds.
+         * @param {any} value - The value to store. Will be serialized.
+         */
+        setItemWithTtl(key, seconds, value) {
+            return instance.setex(key, seconds, encodeToStorageValue(value));
+        },
+    });
+}
+function decodeStorageValue(data) {
+    if (!isCustomFormat(data))
+        return data;
+    const payload = data.subarray(customValueHeaderLength);
+    const type = data[customValueHeader.byteLength];
+    switch (type) {
+        case StorageValueEncodingType.Buffer: return payload;
+        case StorageValueEncodingType.Json:
+            try {
+                return superjson.deserialize(JSON.parse(payload.toString()));
+            }
+            catch {
+                throw new Error('[RedisStorage] Failed to parse JSON payload.');
+            }
+        case StorageValueEncodingType.String: return payload.toString();
+        default:
+            throw new Error(`[RedisStorage] Unknown encoding type: ${type}.`);
+    }
+}
+function encodeToStorageValue(value) {
+    if (node_buffer.Buffer.isBuffer(value))
+        return toCustomValue(StorageValueEncodingType.Buffer, value);
+    if (typeof value === 'string')
+        return toCustomValue(StorageValueEncodingType.String, node_buffer.Buffer.from(value));
+    return toCustomValue(StorageValueEncodingType.Json, node_buffer.Buffer.from(JSON.stringify(superjson.serialize(value))));
+}
+function isCustomFormat(buffer) {
+    return (buffer.length >= customValueHeaderLength
+        && buffer[0] === customValueHeader[0]
+        && buffer[1] === customValueHeader[1]
+        && buffer[2] === customValueHeader[2]);
+}
+function toCustomValue(type, payload) {
+    return node_buffer.Buffer.concat([
+        customValueHeader,
+        node_buffer.Buffer.of(type),
+        payload,
+    ]);
+}
+
+exports.createEnhancedRedisStorage = createEnhancedRedisStorage;
+//# sourceMappingURL=core.cjs.map

package/dist/storage/enhanced/redis/core.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.cjs","sources":["../../../../src/storage/enhanced/redis/core.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\n\nimport { Redis } from 'ioredis';\nimport {\n    deserialize,\n    serialize,\n} from 'superjson';\n\nenum StorageValueEncodingType {\n    Buffer = 0,\n    Json = 1,\n    String = 2,\n}\n\nconst customValueHeader = Buffer.of(\n    0xE2,\n    0x81,\n    0xA0,\n);\n\nconst customValueHeaderLength = customValueHeader.byteLength + 1;\n\n/**\n * Creates an enhanced Redis-based storage interface using SuperJSON encoding.\n *\n * This utility provides a typed, serializable key-value store backed by Redis,\n * supporting TTL operations and safe deserialization of complex types (e.g. Date, Map).\n *\n * @param {Redis | string} ioRedisInstanceOrUrl - Either an existing `ioredis` instance or a Redis connection string.\n *\n * @returns A frozen object that wraps Redis commands with typed get/set logic and encoding.\n *\n * @example\n * ```typescript\n * const redisStorage = createEnhancedRedisStorage('redis://localhost');\n * await redisStorage.setItem('user:1', { name: 'user' });\n * const user = await redisStorage.getItem<{ name: string }>('user:1');\n * ```\n */\nexport function createEnhancedRedisStorage(ioRedisInstanceOrUrl: Redis | string) {\n    const instance = ioRedisInstanceOrUrl instanceof Redis ? ioRedisInstanceOrUrl : new Redis(ioRedisInstanceOrUrl);\n    return Object.freeze({\n        /**\n         * Retrieves a value from Redis and decodes it.\n         *\n         * @template T - The expected return type.\n         *\n         * @param {string} key - The Redis key.\n         *\n         * @returns {Promise<null | T>} The decoded value or null if not found.\n         */\n        async getItem<T = unknown>(key: string) {\n            const rawValue = await instance.getBuffer(key);\n            return rawValue ? decodeStorageValue(rawValue) as T : null;\n        },\n        /**\n         * Gets the remaining TTL (in seconds) for a given key.\n         *\n         * @param {string} key - The Redis key.\n         *\n         * @returns {Promise<number>} The number of seconds until the key expires, or -1 if no expiration is set.\n         */\n        getItemTtl: (key: string) => instance.ttl(key),\n        /**\n         * Checks whether a key exists in Redis.\n         *\n         * @param {string} key - The Redis key.\n         *\n         * @returns {Promise<boolean>} True if the key exists, false otherwise.\n         */\n        hasItem: async (key: string) => await instance.exists(key) === 1,\n        /**\n         * The underlying Redis instance, exposed for advanced operations.\n         * Use with caution; most use cases should rely on the wrapper methods.\n         *\n         * @returns {Redis} The underlying Redis instance.\n         */\n        get instance() {\n            return instance;\n        },\n        /**\n         * Removes a key from Redis.\n         *\n         * @param {string} key - The Redis key to delete.\n         *\n         * @returns {Promise<boolean>} A Promise that resolves to `true` if the key was removed,\n         * or `false` if it did not exist.\n         */\n        removeItem: async (key: string) => await instance.del(key) === 1,\n        /**\n         * Stores a value in Redis without expiration.\n         *\n         * @param {string} key - The Redis key.\n         * @param {any} value - The value to store. Will be serialized.\n         */\n        setItem: (key: string, value: any) => instance.set(key, encodeToStorageValue(value)),\n        /**\n         * Stores a value in Redis with a time-to-live (TTL).\n         *\n         * @param {string} key - The Redis key.\n         * @param {number} seconds - Expiration time in seconds.\n         * @param {any} value - The value to store. Will be serialized.\n         */\n        setItemWithTtl(key: string, seconds: number, value: any) {\n            return instance.setex(key, seconds, encodeToStorageValue(value));\n        },\n    });\n}\n\nfunction decodeStorageValue(data: Buffer) {\n    if (!isCustomFormat(data)) return data;\n    const payload = data.subarray(customValueHeaderLength);\n    const type = data[customValueHeader.byteLength];\n    switch (type) {\n        case StorageValueEncodingType.Buffer: return payload;\n        case StorageValueEncodingType.Json:\n            try {\n                return deserialize(JSON.parse(payload.toString()));\n            } catch {\n                throw new Error('[RedisStorage] Failed to parse JSON payload.');\n            }\n        case StorageValueEncodingType.String: return payload.toString();\n        default:\n            throw new Error(`[RedisStorage] Unknown encoding type: ${type}.`);\n    }\n}\n\nfunction encodeToStorageValue(value: any) {\n    if (Buffer.isBuffer(value)) return toCustomValue(StorageValueEncodingType.Buffer, value);\n    if (typeof value === 'string') return toCustomValue(StorageValueEncodingType.String, Buffer.from(value));\n    return toCustomValue(StorageValueEncodingType.Json, Buffer.from(JSON.stringify(serialize(value))));\n}\n\nfunction isCustomFormat(buffer: Buffer) {\n    return (\n        buffer.length >= customValueHeaderLength\n        && buffer[0] === customValueHeader[0]\n        && buffer[1] === customValueHeader[1]\n        && buffer[2] === customValueHeader[2]\n    );\n}\n\nfunction toCustomValue(type: StorageValueEncodingType, payload: Buffer) {\n    return Buffer.concat([\n        customValueHeader,\n        Buffer.of(type),\n        payload,\n    ]);\n}\n"],"names":["Buffer","Redis","deserialize","serialize"],"mappings":"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"}

package/dist/storage/enhanced/redis/core.d.ts

@@ -0,0 +1,78 @@
+import { Redis } from 'ioredis';
+/**
+ * Creates an enhanced Redis-based storage interface using SuperJSON encoding.
+ *
+ * This utility provides a typed, serializable key-value store backed by Redis,
+ * supporting TTL operations and safe deserialization of complex types (e.g. Date, Map).
+ *
+ * @param {Redis | string} ioRedisInstanceOrUrl - Either an existing `ioredis` instance or a Redis connection string.
+ *
+ * @returns A frozen object that wraps Redis commands with typed get/set logic and encoding.
+ *
+ * @example
+ * ```typescript
+ * const redisStorage = createEnhancedRedisStorage('redis://localhost');
+ * await redisStorage.setItem('user:1', { name: 'user' });
+ * const user = await redisStorage.getItem<{ name: string }>('user:1');
+ * ```
+ */
+export declare function createEnhancedRedisStorage(ioRedisInstanceOrUrl: Redis | string): Readonly<{
+    /**
+     * Retrieves a value from Redis and decodes it.
+     *
+     * @template T - The expected return type.
+     *
+     * @param {string} key - The Redis key.
+     *
+     * @returns {Promise<null | T>} The decoded value or null if not found.
+     */
+    getItem<T = unknown>(key: string): Promise<T | null>;
+    /**
+     * Gets the remaining TTL (in seconds) for a given key.
+     *
+     * @param {string} key - The Redis key.
+     *
+     * @returns {Promise<number>} The number of seconds until the key expires, or -1 if no expiration is set.
+     */
+    getItemTtl: (key: string) => Promise<number>;
+    /**
+     * Checks whether a key exists in Redis.
+     *
+     * @param {string} key - The Redis key.
+     *
+     * @returns {Promise<boolean>} True if the key exists, false otherwise.
+     */
+    hasItem: (key: string) => Promise<boolean>;
+    /**
+     * The underlying Redis instance, exposed for advanced operations.
+     * Use with caution; most use cases should rely on the wrapper methods.
+     *
+     * @returns {Redis} The underlying Redis instance.
+     */
+    readonly instance: Redis;
+    /**
+     * Removes a key from Redis.
+     *
+     * @param {string} key - The Redis key to delete.
+     *
+     * @returns {Promise<boolean>} A Promise that resolves to `true` if the key was removed,
+     * or `false` if it did not exist.
+     */
+    removeItem: (key: string) => Promise<boolean>;
+    /**
+     * Stores a value in Redis without expiration.
+     *
+     * @param {string} key - The Redis key.
+     * @param {any} value - The value to store. Will be serialized.
+     */
+    setItem: (key: string, value: any) => Promise<"OK">;
+    /**
+     * Stores a value in Redis with a time-to-live (TTL).
+     *
+     * @param {string} key - The Redis key.
+     * @param {number} seconds - Expiration time in seconds.
+     * @param {any} value - The value to store. Will be serialized.
+     */
+    setItemWithTtl(key: string, seconds: number, value: any): Promise<"OK">;
+}>;
+//# sourceMappingURL=core.d.ts.map

package/dist/storage/enhanced/redis/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../src/storage/enhanced/redis/core.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAoBhC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,oBAAoB,EAAE,KAAK,GAAG,MAAM;IAGvE;;;;;;;;OAQG;YACW,CAAC,iBAAiB,MAAM;IAItC;;;;;;OAMG;sBACe,MAAM;IACxB;;;;;;OAMG;mBACkB,MAAM;IAC3B;;;;;OAKG;;IAIH;;;;;;;OAOG;sBACqB,MAAM;IAC9B;;;;;OAKG;mBACY,MAAM,SAAS,GAAG;IACjC;;;;;;OAMG;wBACiB,MAAM,WAAW,MAAM,SAAS,GAAG;GAI9D"}

package/dist/storage/enhanced/redis/core.mjs

@@ -0,0 +1,140 @@
+import { Buffer } from 'node:buffer';
+import { Redis } from 'ioredis';
+import { serialize, deserialize } from 'superjson';
+
+var StorageValueEncodingType;
+(function (StorageValueEncodingType) {
+    StorageValueEncodingType[StorageValueEncodingType["Buffer"] = 0] = "Buffer";
+    StorageValueEncodingType[StorageValueEncodingType["Json"] = 1] = "Json";
+    StorageValueEncodingType[StorageValueEncodingType["String"] = 2] = "String";
+})(StorageValueEncodingType || (StorageValueEncodingType = {}));
+const customValueHeader = Buffer.of(0xE2, 0x81, 0xA0);
+const customValueHeaderLength = customValueHeader.byteLength + 1;
+/**
+ * Creates an enhanced Redis-based storage interface using SuperJSON encoding.
+ *
+ * This utility provides a typed, serializable key-value store backed by Redis,
+ * supporting TTL operations and safe deserialization of complex types (e.g. Date, Map).
+ *
+ * @param {Redis | string} ioRedisInstanceOrUrl - Either an existing `ioredis` instance or a Redis connection string.
+ *
+ * @returns A frozen object that wraps Redis commands with typed get/set logic and encoding.
+ *
+ * @example
+ * ```typescript
+ * const redisStorage = createEnhancedRedisStorage('redis://localhost');
+ * await redisStorage.setItem('user:1', { name: 'user' });
+ * const user = await redisStorage.getItem<{ name: string }>('user:1');
+ * ```
+ */
+function createEnhancedRedisStorage(ioRedisInstanceOrUrl) {
+    const instance = ioRedisInstanceOrUrl instanceof Redis ? ioRedisInstanceOrUrl : new Redis(ioRedisInstanceOrUrl);
+    return Object.freeze({
+        /**
+         * Retrieves a value from Redis and decodes it.
+         *
+         * @template T - The expected return type.
+         *
+         * @param {string} key - The Redis key.
+         *
+         * @returns {Promise<null | T>} The decoded value or null if not found.
+         */
+        async getItem(key) {
+            const rawValue = await instance.getBuffer(key);
+            return rawValue ? decodeStorageValue(rawValue) : null;
+        },
+        /**
+         * Gets the remaining TTL (in seconds) for a given key.
+         *
+         * @param {string} key - The Redis key.
+         *
+         * @returns {Promise<number>} The number of seconds until the key expires, or -1 if no expiration is set.
+         */
+        getItemTtl: (key) => instance.ttl(key),
+        /**
+         * Checks whether a key exists in Redis.
+         *
+         * @param {string} key - The Redis key.
+         *
+         * @returns {Promise<boolean>} True if the key exists, false otherwise.
+         */
+        hasItem: async (key) => await instance.exists(key) === 1,
+        /**
+         * The underlying Redis instance, exposed for advanced operations.
+         * Use with caution; most use cases should rely on the wrapper methods.
+         *
+         * @returns {Redis} The underlying Redis instance.
+         */
+        get instance() {
+            return instance;
+        },
+        /**
+         * Removes a key from Redis.
+         *
+         * @param {string} key - The Redis key to delete.
+         *
+         * @returns {Promise<boolean>} A Promise that resolves to `true` if the key was removed,
+         * or `false` if it did not exist.
+         */
+        removeItem: async (key) => await instance.del(key) === 1,
+        /**
+         * Stores a value in Redis without expiration.
+         *
+         * @param {string} key - The Redis key.
+         * @param {any} value - The value to store. Will be serialized.
+         */
+        setItem: (key, value) => instance.set(key, encodeToStorageValue(value)),
+        /**
+         * Stores a value in Redis with a time-to-live (TTL).
+         *
+         * @param {string} key - The Redis key.
+         * @param {number} seconds - Expiration time in seconds.
+         * @param {any} value - The value to store. Will be serialized.
+         */
+        setItemWithTtl(key, seconds, value) {
+            return instance.setex(key, seconds, encodeToStorageValue(value));
+        },
+    });
+}
+function decodeStorageValue(data) {
+    if (!isCustomFormat(data))
+        return data;
+    const payload = data.subarray(customValueHeaderLength);
+    const type = data[customValueHeader.byteLength];
+    switch (type) {
+        case StorageValueEncodingType.Buffer: return payload;
+        case StorageValueEncodingType.Json:
+            try {
+                return deserialize(JSON.parse(payload.toString()));
+            }
+            catch {
+                throw new Error('[RedisStorage] Failed to parse JSON payload.');
+            }
+        case StorageValueEncodingType.String: return payload.toString();
+        default:
+            throw new Error(`[RedisStorage] Unknown encoding type: ${type}.`);
+    }
+}
+function encodeToStorageValue(value) {
+    if (Buffer.isBuffer(value))
+        return toCustomValue(StorageValueEncodingType.Buffer, value);
+    if (typeof value === 'string')
+        return toCustomValue(StorageValueEncodingType.String, Buffer.from(value));
+    return toCustomValue(StorageValueEncodingType.Json, Buffer.from(JSON.stringify(serialize(value))));
+}
+function isCustomFormat(buffer) {
+    return (buffer.length >= customValueHeaderLength
+        && buffer[0] === customValueHeader[0]
+        && buffer[1] === customValueHeader[1]
+        && buffer[2] === customValueHeader[2]);
+}
+function toCustomValue(type, payload) {
+    return Buffer.concat([
+        customValueHeader,
+        Buffer.of(type),
+        payload,
+    ]);
+}
+
+export { createEnhancedRedisStorage };
+//# sourceMappingURL=core.mjs.map

package/dist/storage/enhanced/redis/core.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.mjs","sources":["../../../../src/storage/enhanced/redis/core.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\n\nimport { Redis } from 'ioredis';\nimport {\n    deserialize,\n    serialize,\n} from 'superjson';\n\nenum StorageValueEncodingType {\n    Buffer = 0,\n    Json = 1,\n    String = 2,\n}\n\nconst customValueHeader = Buffer.of(\n    0xE2,\n    0x81,\n    0xA0,\n);\n\nconst customValueHeaderLength = customValueHeader.byteLength + 1;\n\n/**\n * Creates an enhanced Redis-based storage interface using SuperJSON encoding.\n *\n * This utility provides a typed, serializable key-value store backed by Redis,\n * supporting TTL operations and safe deserialization of complex types (e.g. Date, Map).\n *\n * @param {Redis | string} ioRedisInstanceOrUrl - Either an existing `ioredis` instance or a Redis connection string.\n *\n * @returns A frozen object that wraps Redis commands with typed get/set logic and encoding.\n *\n * @example\n * ```typescript\n * const redisStorage = createEnhancedRedisStorage('redis://localhost');\n * await redisStorage.setItem('user:1', { name: 'user' });\n * const user = await redisStorage.getItem<{ name: string }>('user:1');\n * ```\n */\nexport function createEnhancedRedisStorage(ioRedisInstanceOrUrl: Redis | string) {\n    const instance = ioRedisInstanceOrUrl instanceof Redis ? ioRedisInstanceOrUrl : new Redis(ioRedisInstanceOrUrl);\n    return Object.freeze({\n        /**\n         * Retrieves a value from Redis and decodes it.\n         *\n         * @template T - The expected return type.\n         *\n         * @param {string} key - The Redis key.\n         *\n         * @returns {Promise<null | T>} The decoded value or null if not found.\n         */\n        async getItem<T = unknown>(key: string) {\n            const rawValue = await instance.getBuffer(key);\n            return rawValue ? decodeStorageValue(rawValue) as T : null;\n        },\n        /**\n         * Gets the remaining TTL (in seconds) for a given key.\n         *\n         * @param {string} key - The Redis key.\n         *\n         * @returns {Promise<number>} The number of seconds until the key expires, or -1 if no expiration is set.\n         */\n        getItemTtl: (key: string) => instance.ttl(key),\n        /**\n         * Checks whether a key exists in Redis.\n         *\n         * @param {string} key - The Redis key.\n         *\n         * @returns {Promise<boolean>} True if the key exists, false otherwise.\n         */\n        hasItem: async (key: string) => await instance.exists(key) === 1,\n        /**\n         * The underlying Redis instance, exposed for advanced operations.\n         * Use with caution; most use cases should rely on the wrapper methods.\n         *\n         * @returns {Redis} The underlying Redis instance.\n         */\n        get instance() {\n            return instance;\n        },\n        /**\n         * Removes a key from Redis.\n         *\n         * @param {string} key - The Redis key to delete.\n         *\n         * @returns {Promise<boolean>} A Promise that resolves to `true` if the key was removed,\n         * or `false` if it did not exist.\n         */\n        removeItem: async (key: string) => await instance.del(key) === 1,\n        /**\n         * Stores a value in Redis without expiration.\n         *\n         * @param {string} key - The Redis key.\n         * @param {any} value - The value to store. Will be serialized.\n         */\n        setItem: (key: string, value: any) => instance.set(key, encodeToStorageValue(value)),\n        /**\n         * Stores a value in Redis with a time-to-live (TTL).\n         *\n         * @param {string} key - The Redis key.\n         * @param {number} seconds - Expiration time in seconds.\n         * @param {any} value - The value to store. Will be serialized.\n         */\n        setItemWithTtl(key: string, seconds: number, value: any) {\n            return instance.setex(key, seconds, encodeToStorageValue(value));\n        },\n    });\n}\n\nfunction decodeStorageValue(data: Buffer) {\n    if (!isCustomFormat(data)) return data;\n    const payload = data.subarray(customValueHeaderLength);\n    const type = data[customValueHeader.byteLength];\n    switch (type) {\n        case StorageValueEncodingType.Buffer: return payload;\n        case StorageValueEncodingType.Json:\n            try {\n                return deserialize(JSON.parse(payload.toString()));\n            } catch {\n                throw new Error('[RedisStorage] Failed to parse JSON payload.');\n            }\n        case StorageValueEncodingType.String: return payload.toString();\n        default:\n            throw new Error(`[RedisStorage] Unknown encoding type: ${type}.`);\n    }\n}\n\nfunction encodeToStorageValue(value: any) {\n    if (Buffer.isBuffer(value)) return toCustomValue(StorageValueEncodingType.Buffer, value);\n    if (typeof value === 'string') return toCustomValue(StorageValueEncodingType.String, Buffer.from(value));\n    return toCustomValue(StorageValueEncodingType.Json, Buffer.from(JSON.stringify(serialize(value))));\n}\n\nfunction isCustomFormat(buffer: Buffer) {\n    return (\n        buffer.length >= customValueHeaderLength\n        && buffer[0] === customValueHeader[0]\n        && buffer[1] === customValueHeader[1]\n        && buffer[2] === customValueHeader[2]\n    );\n}\n\nfunction toCustomValue(type: StorageValueEncodingType, payload: Buffer) {\n    return Buffer.concat([\n        customValueHeader,\n        Buffer.of(type),\n        payload,\n    ]);\n}\n"],"names":[],"mappings":"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"}

package/dist/storage/enhanced/redis/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+const core = require('./core.cjs');
+const keyedStore = require('./keyed-store.cjs');
+
+
+
+exports.createEnhancedRedisStorage = core.createEnhancedRedisStorage;
+exports.createKeyedEnhancedRedisStore = keyedStore.createKeyedEnhancedRedisStore;
+//# sourceMappingURL=index.cjs.map

package/dist/storage/enhanced/redis/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

package/dist/storage/enhanced/redis/index.d.ts

@@ -0,0 +1,3 @@
+export { createEnhancedRedisStorage } from './core';
+export { createKeyedEnhancedRedisStore } from './keyed-store';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/enhanced/redis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/storage/enhanced/redis/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,QAAQ,CAAC;AACpD,OAAO,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAC"}

package/dist/storage/enhanced/redis/index.mjs

@@ -0,0 +1,3 @@
+export { createEnhancedRedisStorage } from './core.mjs';
+export { createKeyedEnhancedRedisStore } from './keyed-store.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/storage/enhanced/redis/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/storage/enhanced/redis/keyed-store.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+/**
+ * Creates a reusable, type-safe Redis-backed storage interface based on `createEnhancedRedisStorage`
+ * and a dynamic key-generation function.
+ *
+ * This utility abstracts away key construction and provides high-level access
+ * to Redis operations such as `getItem`, `setItem`, `setItemWithTtl`, and `getItemTtl`.
+ * It is ideal for namespaced data, caching, and session handling.
+ *
+ * @template D - The value type to store.
+ *
+ * @param {ReturnType<typeof createEnhancedRedisStorage>} storage - The enhanced Redis storage instance.
+ *
+ * @returns A factory that accepts a key generator function and returns a scoped Redis storage interface.
+ *
+ * @example
+ * ```typescript
+ * const userStore = createKeyedEnhancedRedisStore<User>(redisStorage)((id: number) => `user:${id}`);
+ * await userStore.setItem({ id: 123, name: 'user' }, 123);
+ * const user = await userStore.getItem(123);
+ * ```
+ */
+function createKeyedEnhancedRedisStore(storage) {
+    return (getKeyFunction) => Object.freeze({
+        getItem: (...args) => storage.getItem(getKeyFunction(...args)),
+        getItemTtl: (...args) => storage.getItemTtl(getKeyFunction(...args)),
+        hasItem: (...args) => storage.hasItem(getKeyFunction(...args)),
+        removeItem: (...args) => storage.removeItem(getKeyFunction(...args)),
+        /**
+         * Resolves the storage key from the given arguments.
+         *
+         * @returns {string} The final string key used internally.
+         */
+        resolveKey: (...args) => getKeyFunction(...args),
+        setItem: (value, ...args) => storage.setItem(getKeyFunction(...args), value),
+        setItemWithTtl(seconds, value, ...args) {
+            return storage.setItemWithTtl(getKeyFunction(...args), seconds, value);
+        },
+    });
+}
+
+exports.createKeyedEnhancedRedisStore = createKeyedEnhancedRedisStore;
+//# sourceMappingURL=keyed-store.cjs.map

package/dist/storage/enhanced/redis/keyed-store.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyed-store.cjs","sources":["../../../../src/storage/enhanced/redis/keyed-store.ts"],"sourcesContent":["import type { createEnhancedRedisStorage } from './core';\n\n/**\n * Creates a reusable, type-safe Redis-backed storage interface based on `createEnhancedRedisStorage`\n * and a dynamic key-generation function.\n *\n * This utility abstracts away key construction and provides high-level access\n * to Redis operations such as `getItem`, `setItem`, `setItemWithTtl`, and `getItemTtl`.\n * It is ideal for namespaced data, caching, and session handling.\n *\n * @template D - The value type to store.\n *\n * @param {ReturnType<typeof createEnhancedRedisStorage>} storage - The enhanced Redis storage instance.\n *\n * @returns A factory that accepts a key generator function and returns a scoped Redis storage interface.\n *\n * @example\n * ```typescript\n * const userStore = createKeyedEnhancedRedisStore<User>(redisStorage)((id: number) => `user:${id}`);\n * await userStore.setItem({ id: 123, name: 'user' }, 123);\n * const user = await userStore.getItem(123);\n * ```\n */\nexport function createKeyedEnhancedRedisStore<D = unknown>(storage: ReturnType<typeof createEnhancedRedisStorage>) {\n    return <P extends any[]>(getKeyFunction: (...args: P) => string) => Object.freeze({\n        getItem: (...args: P) => storage.getItem<D>(getKeyFunction(...args)),\n        getItemTtl: (...args: P) => storage.getItemTtl(getKeyFunction(...args)),\n        hasItem: (...args: P) => storage.hasItem(getKeyFunction(...args)),\n        removeItem: (...args: P) => storage.removeItem(getKeyFunction(...args)),\n        /**\n         * Resolves the storage key from the given arguments.\n         *\n         * @returns {string} The final string key used internally.\n         */\n        resolveKey: (...args: P) => getKeyFunction(...args),\n        setItem: (value: D, ...args: P) => storage.setItem(getKeyFunction(...args), value),\n        setItemWithTtl(seconds: number, value: D, ...args: P) {\n            return storage.setItemWithTtl(getKeyFunction(...args), seconds, value);\n        },\n    });\n}\n"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,6BAA6B,CAAc,OAAsD,EAAA;IAC7G,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClF,QAAA,cAAc,CAAC,OAAe,EAAE,KAAQ,EAAE,GAAG,IAAO,EAAA;AAChD,YAAA,OAAO,OAAO,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC;SACzE;AACJ,KAAA,CAAC;AACN;;;;"}

package/dist/storage/enhanced/redis/keyed-store.d.ts

@@ -0,0 +1,37 @@
+import type { createEnhancedRedisStorage } from './core';
+/**
+ * Creates a reusable, type-safe Redis-backed storage interface based on `createEnhancedRedisStorage`
+ * and a dynamic key-generation function.
+ *
+ * This utility abstracts away key construction and provides high-level access
+ * to Redis operations such as `getItem`, `setItem`, `setItemWithTtl`, and `getItemTtl`.
+ * It is ideal for namespaced data, caching, and session handling.
+ *
+ * @template D - The value type to store.
+ *
+ * @param {ReturnType<typeof createEnhancedRedisStorage>} storage - The enhanced Redis storage instance.
+ *
+ * @returns A factory that accepts a key generator function and returns a scoped Redis storage interface.
+ *
+ * @example
+ * ```typescript
+ * const userStore = createKeyedEnhancedRedisStore<User>(redisStorage)((id: number) => `user:${id}`);
+ * await userStore.setItem({ id: 123, name: 'user' }, 123);
+ * const user = await userStore.getItem(123);
+ * ```
+ */
+export declare function createKeyedEnhancedRedisStore<D = unknown>(storage: ReturnType<typeof createEnhancedRedisStorage>): <P extends any[]>(getKeyFunction: (...args: P) => string) => Readonly<{
+    getItem: (...args: P) => Promise<D | null>;
+    getItemTtl: (...args: P) => Promise<number>;
+    hasItem: (...args: P) => Promise<boolean>;
+    removeItem: (...args: P) => Promise<boolean>;
+    /**
+     * Resolves the storage key from the given arguments.
+     *
+     * @returns {string} The final string key used internally.
+     */
+    resolveKey: (...args: P) => string;
+    setItem: (value: D, ...args: P) => Promise<"OK">;
+    setItemWithTtl(seconds: number, value: D, ...args: P): Promise<"OK">;
+}>;
+//# sourceMappingURL=keyed-store.d.ts.map

package/dist/storage/enhanced/redis/keyed-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyed-store.d.ts","sourceRoot":"","sources":["../../../../src/storage/enhanced/redis/keyed-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,QAAQ,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,0BAA0B,CAAC,IACrG,CAAC,SAAS,GAAG,EAAE,EAAE,gBAAgB,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,MAAM;uBACxC,CAAC;0BACE,CAAC;uBACJ,CAAC;0BACE,CAAC;IACvB;;;;OAIG;0BACmB,CAAC;qBACN,CAAC,WAAW,CAAC;4BACN,MAAM,SAAS,CAAC,WAAW,CAAC;GAI3D"}

package/dist/storage/enhanced/redis/keyed-store.mjs

@@ -0,0 +1,42 @@
+/**
+ * Creates a reusable, type-safe Redis-backed storage interface based on `createEnhancedRedisStorage`
+ * and a dynamic key-generation function.
+ *
+ * This utility abstracts away key construction and provides high-level access
+ * to Redis operations such as `getItem`, `setItem`, `setItemWithTtl`, and `getItemTtl`.
+ * It is ideal for namespaced data, caching, and session handling.
+ *
+ * @template D - The value type to store.
+ *
+ * @param {ReturnType<typeof createEnhancedRedisStorage>} storage - The enhanced Redis storage instance.
+ *
+ * @returns A factory that accepts a key generator function and returns a scoped Redis storage interface.
+ *
+ * @example
+ * ```typescript
+ * const userStore = createKeyedEnhancedRedisStore<User>(redisStorage)((id: number) => `user:${id}`);
+ * await userStore.setItem({ id: 123, name: 'user' }, 123);
+ * const user = await userStore.getItem(123);
+ * ```
+ */
+function createKeyedEnhancedRedisStore(storage) {
+    return (getKeyFunction) => Object.freeze({
+        getItem: (...args) => storage.getItem(getKeyFunction(...args)),
+        getItemTtl: (...args) => storage.getItemTtl(getKeyFunction(...args)),
+        hasItem: (...args) => storage.hasItem(getKeyFunction(...args)),
+        removeItem: (...args) => storage.removeItem(getKeyFunction(...args)),
+        /**
+         * Resolves the storage key from the given arguments.
+         *
+         * @returns {string} The final string key used internally.
+         */
+        resolveKey: (...args) => getKeyFunction(...args),
+        setItem: (value, ...args) => storage.setItem(getKeyFunction(...args), value),
+        setItemWithTtl(seconds, value, ...args) {
+            return storage.setItemWithTtl(getKeyFunction(...args), seconds, value);
+        },
+    });
+}
+
+export { createKeyedEnhancedRedisStore };
+//# sourceMappingURL=keyed-store.mjs.map

package/dist/storage/enhanced/redis/keyed-store.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyed-store.mjs","sources":["../../../../src/storage/enhanced/redis/keyed-store.ts"],"sourcesContent":["import type { createEnhancedRedisStorage } from './core';\n\n/**\n * Creates a reusable, type-safe Redis-backed storage interface based on `createEnhancedRedisStorage`\n * and a dynamic key-generation function.\n *\n * This utility abstracts away key construction and provides high-level access\n * to Redis operations such as `getItem`, `setItem`, `setItemWithTtl`, and `getItemTtl`.\n * It is ideal for namespaced data, caching, and session handling.\n *\n * @template D - The value type to store.\n *\n * @param {ReturnType<typeof createEnhancedRedisStorage>} storage - The enhanced Redis storage instance.\n *\n * @returns A factory that accepts a key generator function and returns a scoped Redis storage interface.\n *\n * @example\n * ```typescript\n * const userStore = createKeyedEnhancedRedisStore<User>(redisStorage)((id: number) => `user:${id}`);\n * await userStore.setItem({ id: 123, name: 'user' }, 123);\n * const user = await userStore.getItem(123);\n * ```\n */\nexport function createKeyedEnhancedRedisStore<D = unknown>(storage: ReturnType<typeof createEnhancedRedisStorage>) {\n    return <P extends any[]>(getKeyFunction: (...args: P) => string) => Object.freeze({\n        getItem: (...args: P) => storage.getItem<D>(getKeyFunction(...args)),\n        getItemTtl: (...args: P) => storage.getItemTtl(getKeyFunction(...args)),\n        hasItem: (...args: P) => storage.hasItem(getKeyFunction(...args)),\n        removeItem: (...args: P) => storage.removeItem(getKeyFunction(...args)),\n        /**\n         * Resolves the storage key from the given arguments.\n         *\n         * @returns {string} The final string key used internally.\n         */\n        resolveKey: (...args: P) => getKeyFunction(...args),\n        setItem: (value: D, ...args: P) => storage.setItem(getKeyFunction(...args), value),\n        setItemWithTtl(seconds: number, value: D, ...args: P) {\n            return storage.setItemWithTtl(getKeyFunction(...args), seconds, value);\n        },\n    });\n}\n"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,6BAA6B,CAAc,OAAsD,EAAA;IAC7G,OAAO,CAAkB,cAAsC,KAAK,MAAM,CAAC,MAAM,CAAC;AAC9E,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAI,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACpE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE,QAAA,OAAO,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACjE,QAAA,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,CAAC;AACvE;;;;AAIG;QACH,UAAU,EAAE,CAAC,GAAG,IAAO,KAAK,cAAc,CAAC,GAAG,IAAI,CAAC;QACnD,OAAO,EAAE,CAAC,KAAQ,EAAE,GAAG,IAAO,KAAK,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,KAAK,CAAC;AAClF,QAAA,cAAc,CAAC,OAAe,EAAE,KAAQ,EAAE,GAAG,IAAO,EAAA;AAChD,YAAA,OAAO,OAAO,CAAC,cAAc,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC;SACzE;AACJ,KAAA,CAAC;AACN;;;;"}