lakutata 2.0.66 → 2.0.68

package/vendor/Package.67.mjs

@@ -1,652 +1,710 @@
-import { createClient as t, createCluster as e } from "@redis/client";
+import { Buffer as e } from "buffer";
 
-export { createClient, createCluster } from "@redis/client";
-
-import { K as s } from "./Package.66.mjs";
-
-import r from "cluster-key-slot";
+var t = s => {
+    if (s === void 0 || s === null) {
+        return "null";
+    }
+    if (typeof s === "string") {
+        return JSON.stringify(s.startsWith(":") ? ":" + s : s);
+    }
+    if (e.isBuffer(s)) {
+        return JSON.stringify(":base64:" + s.toString("base64"));
+    }
+    if (s?.toJSON) {
+        s = s.toJSON();
+    }
+    if (typeof s === "object") {
+        let e = "";
+        const i = Array.isArray(s);
+        e = i ? "[" : "{";
+        let r = true;
+        for (const o in s) {
+            const a = typeof s[o] === "function" || !i && s[o] === void 0;
+            if (!Object.hasOwn(s, o) || a) {
+                continue;
+            }
+            if (!r) {
+                e += ",";
+            }
+            r = false;
+            if (i) {
+                e += t(s[o]);
+            } else if (s[o] !== void 0) {
+                e += t(o) + ":" + t(s[o]);
+            }
+        }
+        e += i ? "]" : "}";
+        return e;
+    }
+    return JSON.stringify(s);
+};
 
-import "buffer";
+var s = t => JSON.parse(t, ((t, s) => {
+    if (typeof s === "string") {
+        if (s.startsWith(":base64:")) {
+            return e.from(s.slice(8), "base64");
+        }
+        return s.startsWith(":") ? s.slice(1) : s;
+    }
+    return s;
+}));
 
 var i = class {
     _eventListeners;
     _maxListeners;
-    _logger;
-    constructor(t) {
-        this._eventListeners = new Map, this._maxListeners = 100, this._logger = t?.logger;
-    }
-    once(t, e) {
-        let s = (...r) => {
-            this.off(t, s), e(...r);
-        };
-        return this.on(t, s), this;
-    }
-    listenerCount(t) {
-        if (!t) return this.getAllListeners().length;
-        let e = this._eventListeners.get(t);
-        return e ? e.length : 0;
-    }
-    eventNames() {
-        return [ ...this._eventListeners.keys() ];
-    }
-    rawListeners(t) {
-        return t ? this._eventListeners.get(t) ?? [] : this.getAllListeners();
-    }
-    prependListener(t, e) {
-        let s = this._eventListeners.get(t) ?? [];
-        return s.unshift(e), this._eventListeners.set(t, s), this;
-    }
-    prependOnceListener(t, e) {
-        let s = (...r) => {
-            this.off(t, s), e(...r);
-        };
-        return this.prependListener(t, s), this;
+    constructor() {
+        this._eventListeners = new Map;
+        this._maxListeners = 100;
     }
     maxListeners() {
         return this._maxListeners;
     }
-    addListener(t, e) {
-        return this.on(t, e), this;
+    addListener(e, t) {
+        this.on(e, t);
     }
-    on(t, e) {
-        this._eventListeners.has(t) || this._eventListeners.set(t, []);
-        let s = this._eventListeners.get(t);
-        return s && (s.length >= this._maxListeners && console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${s.length + 1} ${t} listeners added. Use setMaxListeners() to increase limit.`), 
-        s.push(e)), this;
+    on(e, t) {
+        if (!this._eventListeners.has(e)) {
+            this._eventListeners.set(e, []);
+        }
+        const s = this._eventListeners.get(e);
+        if (s) {
+            if (s.length >= this._maxListeners) {
+                console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${s.length + 1} ${e} listeners added. Use setMaxListeners() to increase limit.`);
+            }
+            s.push(t);
+        }
+        return this;
     }
-    removeListener(t, e) {
-        return this.off(t, e), this;
+    removeListener(e, t) {
+        this.off(e, t);
     }
-    off(t, e) {
-        let s = this._eventListeners.get(t) ?? [], r = s.indexOf(e);
-        return r !== -1 && s.splice(r, 1), s.length === 0 && this._eventListeners.delete(t), 
-        this;
+    off(e, t) {
+        const s = this._eventListeners.get(e) ?? [];
+        const i = s.indexOf(t);
+        if (i !== -1) {
+            s.splice(i, 1);
+        }
+        if (s.length === 0) {
+            this._eventListeners.delete(e);
+        }
     }
-    emit(t, ...e) {
-        let s = !1, r = this._eventListeners.get(t);
-        if (r && r.length > 0) for (let t of r) t(...e), s = !0;
-        return s;
+    once(e, t) {
+        const s = (...i) => {
+            t(...i);
+            this.off(e, s);
+        };
+        this.on(e, s);
     }
-    listeners(t) {
-        return this._eventListeners.get(t) ?? [];
+    emit(e, ...t) {
+        const s = this._eventListeners.get(e);
+        if (s && s.length > 0) {
+            for (const e of s) {
+                e(...t);
+            }
+        }
     }
-    removeAllListeners(t) {
-        return t ? this._eventListeners.delete(t) : this._eventListeners.clear(), this;
+    listeners(e) {
+        return this._eventListeners.get(e) ?? [];
     }
-    setMaxListeners(t) {
-        this._maxListeners = t;
-        for (let e of this._eventListeners.values()) e.length > t && e.splice(t);
+    removeAllListeners(e) {
+        if (e) {
+            this._eventListeners.delete(e);
+        } else {
+            this._eventListeners.clear();
+        }
     }
-    getAllListeners() {
-        let t = new Array;
-        for (let e of this._eventListeners.values()) t = [ ...t, ...e ];
-        return t;
+    setMaxListeners(e) {
+        this._maxListeners = e;
     }
 };
 
-var n = class extends i {
-    _hooks;
-    _throwHookErrors=!1;
-    constructor(t) {
-        super({
-            logger: t?.logger
-        }), this._hooks = new Map, t?.throwHookErrors !== void 0 && (this._throwHookErrors = t.throwHookErrors);
-    }
-    get hooks() {
-        return this._hooks;
-    }
-    get throwHookErrors() {
-        return this._throwHookErrors;
-    }
-    set throwHookErrors(t) {
-        this._throwHookErrors = t;
-    }
-    get logger() {
-        return this._logger;
-    }
-    set logger(t) {
-        this._logger = t;
-    }
-    onHook(t, e) {
-        let s = this._hooks.get(t);
-        s ? s.push(e) : this._hooks.set(t, [ e ]);
-    }
-    addHook(t, e) {
-        this.onHook(t, e);
+var r = i;
+
+var o = class extends r {
+    _hookHandlers;
+    constructor() {
+        super();
+        this._hookHandlers = new Map;
     }
-    onHooks(t) {
-        for (let e of t) this.onHook(e.event, e.handler);
+    addHandler(e, t) {
+        const s = this._hookHandlers.get(e);
+        if (s) {
+            s.push(t);
+        } else {
+            this._hookHandlers.set(e, [ t ]);
+        }
     }
-    prependHook(t, e) {
-        let s = this._hooks.get(t);
-        s ? s.unshift(e) : this._hooks.set(t, [ e ]);
+    removeHandler(e, t) {
+        const s = this._hookHandlers.get(e);
+        if (s) {
+            const e = s.indexOf(t);
+            if (e !== -1) {
+                s.splice(e, 1);
+            }
+        }
     }
-    prependOnceHook(t, e) {
-        let s = async (...r) => (this.removeHook(t, s), e(...r));
-        this.prependHook(t, s);
+    trigger(e, t) {
+        const s = this._hookHandlers.get(e);
+        if (s) {
+            for (const i of s) {
+                try {
+                    i(t);
+                } catch (t) {
+                    this.emit("error", new Error(`Error in hook handler for event "${e}": ${t.message}`));
+                }
+            }
+        }
     }
-    onceHook(t, e) {
-        let s = async (...r) => (this.removeHook(t, s), e(...r));
-        this.onHook(t, s);
+    get handlers() {
+        return new Map(this._hookHandlers);
     }
-    removeHook(t, e) {
-        let s = this._hooks.get(t);
-        if (s) {
-            let t = s.indexOf(e);
-            t !== -1 && s.splice(t, 1);
+};
+
+var a = o;
+
+var n = class extends r {
+    enabled=true;
+    hits=0;
+    misses=0;
+    sets=0;
+    deletes=0;
+    errors=0;
+    constructor(e) {
+        super();
+        if (e !== void 0) {
+            this.enabled = e;
         }
+        this.reset();
     }
-    removeHooks(t) {
-        for (let e of t) this.removeHook(e.event, e.handler);
+    hit() {
+        if (this.enabled) {
+            this.hits++;
+        }
     }
-    async hook(t, ...e) {
-        let s = this._hooks.get(t);
-        if (s) for (let r of s) try {
-            await r(...e);
-        } catch (e) {
-            let s = `${t}: ${e.message}`;
-            if (this.emit("error", new Error(s)), this._logger && this._logger.error(s), this._throwHookErrors) throw new Error(s);
+    miss() {
+        if (this.enabled) {
+            this.misses++;
         }
     }
-    async callHook(t, ...e) {
-        await this.hook(t, ...e);
+    set() {
+        if (this.enabled) {
+            this.sets++;
+        }
     }
-    getHooks(t) {
-        return this._hooks.get(t);
+    delete() {
+        if (this.enabled) {
+            this.deletes++;
+        }
     }
-    clearHooks() {
-        this._hooks.clear();
+    reset() {
+        this.hits = 0;
+        this.misses = 0;
+        this.sets = 0;
+        this.deletes = 0;
+        this.errors = 0;
     }
 };
 
-var o = (t => {
-    t["RedisClientNotConnectedThrown"] = "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.";
-    return t;
-})(o || {});
+var h = n;
 
-var a = t => {
-    const e = Math.min(2 ** t * 100, 2e3);
-    const s = (Math.random() - .5) * 100;
-    return e + s;
-};
+var l = (e => {
+    e["PRE_SET"] = "preSet";
+    e["POST_SET"] = "postSet";
+    e["PRE_GET"] = "preGet";
+    e["POST_GET"] = "postGet";
+    e["PRE_GET_MANY"] = "preGetMany";
+    e["POST_GET_MANY"] = "postGetMany";
+    e["PRE_DELETE"] = "preDelete";
+    e["POST_DELETE"] = "postDelete";
+    return e;
+})(l || {});
 
-var c = class extends n {
-    _client=t();
+var c = [ "sqlite", "postgres", "mysql", "mongo", "redis", "valkey", "etcd" ];
+
+var f = class extends r {
+    opts;
+    iterator;
+    hooks=new a;
+    stats=new h(false);
+    _ttl;
     _namespace;
-    _keyPrefixSeparator="::";
-    _clearBatchSize=1e3;
-    _useUnlink=true;
-    _noNamespaceAffectsAll=false;
-    _throwOnConnectError=true;
-    _throwErrors=false;
-    _connectionTimeout;
-    constructor(s, r) {
+    _store=new Map;
+    _serialize=t;
+    _deserialize=s;
+    _compression;
+    _useKeyPrefix=true;
+    constructor(e, i) {
         super();
-        const i = {
-            reconnectStrategy: a
+        i ??= {};
+        e ??= {};
+        this.opts = {
+            namespace: "keyv",
+            serialize: t,
+            deserialize: s,
+            emitErrors: true,
+            store: new Map,
+            ...i
         };
-        if (s) {
-            if (typeof s === "string") {
-                this._client = t({
-                    url: s,
-                    socket: i
-                });
-            } else if (s.connect !== void 0) {
-                this._client = this.isClientCluster(s) ? s : s;
-            } else if (s instanceof Object) {
-                this._client = s.rootNodes === void 0 ? t(s) : e(s);
+        if (e && e.get) {
+            this.opts.store = e;
+        } else {
+            this.opts = {
+                ...this.opts,
+                ...e
+            };
+        }
+        this._store = this.opts.store ?? new Map;
+        this._compression = this.opts.compression;
+        this._serialize = this.opts.serialize;
+        this._deserialize = this.opts.deserialize;
+        if (this.opts.namespace) {
+            this._namespace = this.opts.namespace;
+        }
+        if (this._store) {
+            if (!this._isValidStorageAdapter(this._store)) {
+                throw new Error("Invalid storage adapter");
+            }
+            if (typeof this._store.on === "function") {
+                this._store.on("error", (e => this.emit("error", e)));
+            }
+            this._store.namespace = this._namespace;
+            if (typeof this._store[Symbol.iterator] === "function" && this._store instanceof Map) {
+                this.iterator = this.generateIterator(this._store);
+            } else if ("iterator" in this._store && this._store.opts && this._checkIterableAdapter()) {
+                this.iterator = this.generateIterator(this._store.iterator.bind(this._store));
             }
         }
-        this.setOptions(r);
-        this.initClient();
-    }
-    get client() {
-        return this._client;
+        if (this.opts.stats) {
+            this.stats.enabled = this.opts.stats;
+        }
+        if (this.opts.ttl) {
+            this._ttl = this.opts.ttl;
+        }
+        if (this.opts.useKeyPrefix !== void 0) {
+            this._useKeyPrefix = this.opts.useKeyPrefix;
+        }
     }
-    set client(t) {
-        this._client = t;
-        this.initClient();
+    get store() {
+        return this._store;
     }
-    get opts() {
-        let t = "redis://localhost:6379";
-        if (this._client.options) {
-            const e = this._client.options?.url;
-            if (e) {
-                t = e;
+    set store(e) {
+        if (this._isValidStorageAdapter(e)) {
+            this._store = e;
+            this.opts.store = e;
+            if (typeof e.on === "function") {
+                e.on("error", (e => this.emit("error", e)));
+            }
+            if (this._namespace) {
+                this._store.namespace = this._namespace;
+            }
+            if (typeof e[Symbol.iterator] === "function" && e instanceof Map) {
+                this.iterator = this.generateIterator(e);
+            } else if ("iterator" in e && e.opts && this._checkIterableAdapter()) {
+                this.iterator = this.generateIterator(e.iterator.bind(e));
             }
+        } else {
+            throw new Error("Invalid storage adapter");
         }
-        const e = {
-            namespace: this._namespace,
-            keyPrefixSeparator: this._keyPrefixSeparator,
-            clearBatchSize: this._clearBatchSize,
-            noNamespaceAffectsAll: this._noNamespaceAffectsAll,
-            useUnlink: this._useUnlink,
-            throwOnConnectError: this._throwOnConnectError,
-            throwErrors: this._throwErrors,
-            connectionTimeout: this._connectionTimeout,
-            dialect: "redis",
-            url: t
-        };
-        return e;
     }
-    set opts(t) {
-        this.setOptions(t);
+    get compression() {
+        return this._compression;
+    }
+    set compression(e) {
+        this._compression = e;
     }
     get namespace() {
         return this._namespace;
     }
-    set namespace(t) {
-        this._namespace = t;
-    }
-    get keyPrefixSeparator() {
-        return this._keyPrefixSeparator;
-    }
-    set keyPrefixSeparator(t) {
-        this._keyPrefixSeparator = t;
-    }
-    get clearBatchSize() {
-        return this._clearBatchSize;
-    }
-    set clearBatchSize(t) {
-        if (t > 0) {
-            this._clearBatchSize = t;
-        } else {
-            this.emit("error", "clearBatchSize must be greater than 0");
+    set namespace(e) {
+        this._namespace = e;
+        this.opts.namespace = e;
+        this._store.namespace = e;
+        if (this.opts.store) {
+            this.opts.store.namespace = e;
         }
     }
-    get useUnlink() {
-        return this._useUnlink;
+    get ttl() {
+        return this._ttl;
+    }
+    set ttl(e) {
+        this.opts.ttl = e;
+        this._ttl = e;
     }
-    set useUnlink(t) {
-        this._useUnlink = t;
+    get serialize() {
+        return this._serialize;
     }
-    get noNamespaceAffectsAll() {
-        return this._noNamespaceAffectsAll;
+    set serialize(e) {
+        this.opts.serialize = e;
+        this._serialize = e;
     }
-    set noNamespaceAffectsAll(t) {
-        this._noNamespaceAffectsAll = t;
+    get deserialize() {
+        return this._deserialize;
     }
-    get throwOnConnectError() {
-        return this._throwOnConnectError;
+    set deserialize(e) {
+        this.opts.deserialize = e;
+        this._deserialize = e;
     }
-    set throwOnConnectError(t) {
-        this._throwOnConnectError = t;
+    get useKeyPrefix() {
+        return this._useKeyPrefix;
     }
-    get throwErrors() {
-        return this._throwErrors;
+    set useKeyPrefix(e) {
+        this._useKeyPrefix = e;
+        this.opts.useKeyPrefix = e;
     }
-    set throwErrors(t) {
-        this._throwErrors = t;
+    generateIterator(e) {
+        const t = async function*() {
+            for await (const [t, s] of typeof e === "function" ? e(this._store.namespace) : e) {
+                const e = await this.deserializeData(s);
+                if (this._useKeyPrefix && this._store.namespace && !t.includes(this._store.namespace)) {
+                    continue;
+                }
+                if (typeof e.expires === "number" && Date.now() > e.expires) {
+                    this.delete(t);
+                    continue;
+                }
+                yield [ this._getKeyUnprefix(t), e.value ];
+            }
+        };
+        return t.bind(this);
     }
-    get connectionTimeout() {
-        return this._connectionTimeout;
+    _checkIterableAdapter() {
+        return c.includes(this._store.opts.dialect) || c.some((e => this._store.opts.url.includes(e)));
     }
-    set connectionTimeout(t) {
-        this._connectionTimeout = t;
+    _getKeyPrefix(e) {
+        if (!this._useKeyPrefix) {
+            return e;
+        }
+        if (!this._namespace) {
+            return e;
+        }
+        return `${this._namespace}:${e}`;
     }
-    async getClient() {
-        if (this._client.isOpen) {
-            return this._client;
+    _getKeyPrefixArray(e) {
+        if (!this._useKeyPrefix) {
+            return e;
         }
-        try {
-            if (this._connectionTimeout === void 0) {
-                await this._client.connect();
-            } else {
-                await Promise.race([ this._client.connect(), this.createTimeoutPromise(this._connectionTimeout) ]);
-            }
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwOnConnectError) {
-                throw new Error("Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.");
-            }
-            await this.disconnect(true);
+        if (!this._namespace) {
+            return e;
         }
-        this.initClient();
-        return this._client;
+        return e.map((e => `${this._namespace}:${e}`));
     }
-    async set(t, e, s) {
-        const r = await this.getClient();
-        try {
-            t = this.createKeyPrefix(t, this._namespace);
-            if (s) {
-                await r.set(t, e, {
-                    PX: s
+    _getKeyUnprefix(e) {
+        if (!this._useKeyPrefix) {
+            return e;
+        }
+        return e.split(":").splice(1).join(":");
+    }
+    _isValidStorageAdapter(e) {
+        return e instanceof Map || typeof e.get === "function" && typeof e.set === "function" && typeof e.delete === "function" && typeof e.clear === "function";
+    }
+    async get(e, t) {
+        const {store: s} = this.opts;
+        const i = Array.isArray(e);
+        const r = i ? this._getKeyPrefixArray(e) : this._getKeyPrefix(e);
+        const o = e => typeof e.expires === "number" && Date.now() > e.expires;
+        if (i) {
+            if (t?.raw === true) {
+                return this.getMany(e, {
+                    raw: true
                 });
-            } else {
-                await r.set(t, e);
-            }
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
             }
+            return this.getMany(e, {
+                raw: false
+            });
+        }
+        this.hooks.trigger("preGet", {
+            key: r
+        });
+        const a = await s.get(r);
+        const n = typeof a === "string" || this.opts.compression ? await this.deserializeData(a) : a;
+        if (n === void 0 || n === null) {
+            this.stats.miss();
+            return void 0;
         }
-    }
-    async setMany(t) {
-        const e = await this.getClient();
-        try {
-            const s = e.multi();
-            for (const {key: e, value: r, ttl: i} of t) {
-                const t = this.createKeyPrefix(e, this._namespace);
-                if (i) {
-                    s.set(t, r, {
-                        PX: i
-                    });
-                } else {
-                    s.set(t, r);
+        if (o(n)) {
+            await this.delete(e);
+            this.stats.miss();
+            return void 0;
+        }
+        this.hooks.trigger("postGet", {
+            key: r,
+            value: n
+        });
+        this.stats.hit();
+        return t?.raw ? n : n.value;
+    }
+    async getMany(e, t) {
+        const {store: s} = this.opts;
+        const i = this._getKeyPrefixArray(e);
+        const r = e => typeof e.expires === "number" && Date.now() > e.expires;
+        this.hooks.trigger("preGetMany", {
+            keys: i
+        });
+        if (s.getMany === void 0) {
+            const e = i.map((async e => {
+                const i = await s.get(e);
+                const o = typeof i === "string" || this.opts.compression ? await this.deserializeData(i) : i;
+                if (o === void 0 || o === null) {
+                    return void 0;
+                }
+                if (r(o)) {
+                    await this.delete(e);
+                    return void 0;
                 }
+                return t?.raw ? o : o.value;
+            }));
+            const o = await Promise.allSettled(e);
+            const a = o.map((e => e.value));
+            this.hooks.trigger("postGetMany", a);
+            if (a.length > 0) {
+                this.stats.hit();
             }
-            await s.exec();
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
+            return a;
+        }
+        const o = await s.getMany(i);
+        const a = [];
+        for (const s in o) {
+            let i = o[s];
+            if (typeof i === "string") {
+                i = await this.deserializeData(i);
             }
-        }
-    }
-    async has(t) {
-        const e = await this.getClient();
-        try {
-            t = this.createKeyPrefix(t, this._namespace);
-            const s = await e.exists(t);
-            return s === 1;
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
+            if (i === void 0 || i === null) {
+                a.push(void 0);
+                continue;
             }
-            return false;
+            if (r(i)) {
+                await this.delete(e[s]);
+                a.push(void 0);
+                continue;
+            }
+            const n = t?.raw ? i : i.value;
+            a.push(n);
+        }
+        this.hooks.trigger("postGetMany", a);
+        if (a.length > 0) {
+            this.stats.hit();
         }
+        return a;
     }
-    async hasMany(t) {
-        const e = await this.getClient();
+    async set(e, t, s) {
+        const i = {
+            key: e,
+            value: t,
+            ttl: s
+        };
+        this.hooks.trigger("preSet", i);
+        const r = this._getKeyPrefix(i.key);
+        i.ttl ??= this._ttl;
+        if (i.ttl === 0) {
+            i.ttl = void 0;
+        }
+        const {store: o} = this.opts;
+        const a = typeof i.ttl === "number" ? Date.now() + i.ttl : void 0;
+        if (typeof i.value === "symbol") {
+            this.emit("error", "symbol cannot be serialized");
+            throw new Error("symbol cannot be serialized");
+        }
+        const n = {
+            value: i.value,
+            expires: a
+        };
+        const h = await this.serializeData(n);
+        let l = true;
         try {
-            const s = e.multi();
-            for (const e of t) {
-                const t = this.createKeyPrefix(e, this._namespace);
-                s.exists(t);
+            const e = await o.set(r, h, i.ttl);
+            if (typeof e === "boolean") {
+                l = e;
             }
-            const r = await s.exec();
-            return r.map((t => t === 1));
         } catch (e) {
+            l = false;
             this.emit("error", e);
-            if (this._throwErrors) {
-                throw e;
-            }
-            return Array.from({
-                length: t.length
-            }).fill(false);
         }
+        this.hooks.trigger("postSet", {
+            key: r,
+            value: h,
+            ttl: s
+        });
+        this.stats.set();
+        return l;
     }
-    async get(t) {
-        const e = await this.getClient();
+    async setMany(e) {
+        let t = [];
         try {
-            t = this.createKeyPrefix(t, this._namespace);
-            const s = await e.get(t);
-            if (s === null) {
-                return void 0;
+            if (this._store.setMany !== void 0) {
+                const s = await Promise.all(e.map((async ({key: e, value: t, ttl: s}) => {
+                    s ??= this._ttl;
+                    if (s === 0) {
+                        s = void 0;
+                    }
+                    const i = typeof s === "number" ? Date.now() + s : void 0;
+                    if (typeof t === "symbol") {
+                        this.emit("error", "symbol cannot be serialized");
+                        throw new Error("symbol cannot be serialized");
+                    }
+                    const r = {
+                        value: t,
+                        expires: i
+                    };
+                    const o = await this.serializeData(r);
+                    return {
+                        key: e,
+                        value: o,
+                        ttl: s
+                    };
+                })));
+                t = await this._store.setMany(s);
             }
-            return s;
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
+            const s = [];
+            for (const t of e) {
+                s.push(this.set(t.key, t.value, t.ttl));
             }
-            return void 0;
+            const i = await Promise.allSettled(s);
+            t = i.map((e => e.value));
+        } catch (s) {
+            this.emit("error", s);
+            t = e.map((() => false));
         }
+        return t;
     }
-    async getMany(t) {
-        if (t.length === 0) {
-            return [];
+    async delete(e) {
+        const {store: t} = this.opts;
+        if (Array.isArray(e)) {
+            return this.deleteMany(e);
         }
-        t = t.map((t => this.createKeyPrefix(t, this._namespace)));
+        const s = this._getKeyPrefix(e);
+        this.hooks.trigger("preDelete", {
+            key: s
+        });
+        let i = true;
         try {
-            const e = await this.mget(t);
-            return e;
+            const e = await t.delete(s);
+            if (typeof e === "boolean") {
+                i = e;
+            }
         } catch (e) {
+            i = false;
             this.emit("error", e);
-            if (this._throwErrors) {
-                throw e;
-            }
-            return Array.from({
-                length: t.length
-            }).fill(void 0);
         }
+        this.hooks.trigger("postDelete", {
+            key: s,
+            value: i
+        });
+        this.stats.delete();
+        return i;
     }
-    async delete(t) {
-        const e = await this.getClient();
+    async deleteMany(e) {
         try {
-            t = this.createKeyPrefix(t, this._namespace);
-            let s = 0;
-            s = await (this._useUnlink ? e.unlink(t) : e.del(t));
-            return s > 0;
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
+            const {store: t} = this.opts;
+            const s = this._getKeyPrefixArray(e);
+            this.hooks.trigger("preDelete", {
+                key: s
+            });
+            if (t.deleteMany !== void 0) {
+                return await t.deleteMany(s);
             }
+            const i = s.map((async e => t.delete(e)));
+            const r = await Promise.allSettled(i);
+            const o = r.every((e => e.value === true));
+            this.hooks.trigger("postDelete", {
+                key: s,
+                value: o
+            });
+            return o;
+        } catch (e) {
+            this.emit("error", e);
             return false;
         }
     }
-    async deleteMany(t) {
-        let e = false;
-        const s = await this.getClient();
+    async clear() {
+        this.emit("clear");
+        const {store: e} = this.opts;
         try {
-            const r = s.multi();
-            for (const e of t) {
-                const t = this.createKeyPrefix(e, this._namespace);
-                if (this._useUnlink) {
-                    r.unlink(t);
-                } else {
-                    r.del(t);
-                }
-            }
-            const i = await r.exec();
-            for (const t of i) {
-                if (typeof t === "number" && t > 0) {
-                    e = true;
-                }
-            }
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
-            }
-        }
-        return e;
-    }
-    async disconnect(t) {
-        if (this._client.isOpen) {
-            await (t ? this._client.disconnect() : this._client.quit());
-        }
-    }
-    createKeyPrefix(t, e) {
-        if (e) {
-            return `${e}${this._keyPrefixSeparator}${t}`;
+            await e.clear();
+        } catch (e) {
+            this.emit("error", e);
         }
-        return t;
     }
-    getKeyWithoutPrefix(t, e) {
-        if (e) {
-            return t.replace(`${e}${this._keyPrefixSeparator}`, "");
+    async has(e) {
+        if (Array.isArray(e)) {
+            return this.hasMany(e);
         }
-        return t;
-    }
-    isCluster() {
-        return this.isClientCluster(this._client);
-    }
-    async getMasterNodes() {
-        if (this.isCluster()) {
-            const t = await this.getClient();
-            return Promise.all(t.masters.map((async e => t.nodeClient(e))));
-        }
-        return [ await this.getClient() ];
-    }
-    async* iterator(t) {
-        const e = await this.getMasterNodes();
-        for (const s of e) {
-            const e = t ? `${t}${this._keyPrefixSeparator}*` : "*";
-            let r = "0";
-            do {
-                const i = await s.scan(Number.parseInt(r, 10), {
-                    MATCH: e,
-                    TYPE: "string"
-                });
-                r = i.cursor.toString();
-                let {keys: n} = i;
-                if (!t && !this._noNamespaceAffectsAll) {
-                    n = n.filter((t => !t.includes(this._keyPrefixSeparator)));
-                }
-                if (n.length > 0) {
-                    const e = await this.mget(n);
-                    for (const s of n.keys()) {
-                        const r = this.getKeyWithoutPrefix(n[s], t);
-                        const i = e[s];
-                        yield [ r, i ];
-                    }
-                }
-            } while (r !== "0");
+        const t = this._getKeyPrefix(e);
+        const {store: s} = this.opts;
+        if (s.has !== void 0 && !(s instanceof Map)) {
+            return s.has(t);
         }
-    }
-    async clear() {
+        let i;
         try {
-            const t = await this.getMasterNodes();
-            await Promise.all(t.map((async t => {
-                if (!this._namespace && this._noNamespaceAffectsAll) {
-                    await t.flushDb();
-                    return;
+            i = await s.get(t);
+        } catch (e) {
+            this.emit("error", e);
+        }
+        if (i) {
+            const e = await this.deserializeData(i);
+            if (e) {
+                if (e.expires === void 0 || e.expires === null) {
+                    return true;
                 }
-                let e = "0";
-                const s = this._clearBatchSize;
-                const r = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
-                const i = [];
-                do {
-                    const n = await t.scan(Number.parseInt(e, 10), {
-                        MATCH: r,
-                        COUNT: s,
-                        TYPE: "string"
-                    });
-                    e = n.cursor.toString();
-                    let {keys: o} = n;
-                    if (o.length === 0) {
-                        continue;
-                    }
-                    if (!this._namespace) {
-                        o = o.filter((t => !t.includes(this._keyPrefixSeparator)));
-                    }
-                    i.push(this.clearWithClusterSupport(o));
-                } while (e !== "0");
-                await Promise.all(i);
-            })));
-        } catch (t) {
-            this.emit("error", t);
-        }
-    }
-    async mget(t) {
-        const e = this.getSlotMap(t);
-        const s = new Map;
-        await Promise.all(Array.from(e.entries(), (async ([t, e]) => {
-            const r = await this.getSlotMaster(t);
-            const i = await r.mGet(e);
-            for (const [t, r] of i.entries()) {
-                s.set(e[t], r ?? void 0);
+                return e.expires > Date.now();
             }
-        })));
-        return t.map((t => s.get(t)));
-    }
-    async clearWithClusterSupport(t) {
-        if (t.length > 0) {
-            const e = this.getSlotMap(t);
-            await Promise.all(Array.from(e.entries(), (async ([t, e]) => {
-                const s = await this.getSlotMaster(t);
-                return this._useUnlink ? s.unlink(e) : s.del(e);
-            })));
         }
+        return false;
     }
-    async getSlotMaster(t) {
-        const e = await this.getClient();
-        if (this.isCluster()) {
-            const s = e;
-            const r = s.slots[t].master;
-            return s.nodeClient(r);
+    async hasMany(e) {
+        const t = this._getKeyPrefixArray(e);
+        const {store: s} = this.opts;
+        if (s.hasMany !== void 0) {
+            return s.hasMany(t);
         }
-        return e;
-    }
-    getSlotMap(t) {
-        const e = new Map;
-        if (this.isCluster()) {
-            for (const s of t) {
-                const t = r(s);
-                const i = e.get(t) ?? [];
-                i.push(s);
-                e.set(t, i);
-            }
-        } else {
-            e.set(0, t);
+        const i = [];
+        for (const e of t) {
+            i.push(await this.has(e));
         }
-        return e;
+        return i;
     }
-    isClientCluster(t) {
-        if (t.options === void 0 && t.scan === void 0) {
-            return true;
+    async disconnect() {
+        const {store: e} = this.opts;
+        this.emit("disconnect");
+        if (typeof e.disconnect === "function") {
+            return e.disconnect();
         }
-        return false;
     }
-    setOptions(t) {
-        if (!t) {
+    emit(e, ...t) {
+        if (e === "error" && !this.opts.emitErrors) {
             return;
         }
-        if (t.namespace) {
-            this._namespace = t.namespace;
-        }
-        if (t.keyPrefixSeparator !== void 0) {
-            this._keyPrefixSeparator = t.keyPrefixSeparator;
-        }
-        if (t.clearBatchSize !== void 0 && t.clearBatchSize > 0) {
-            this._clearBatchSize = t.clearBatchSize;
-        }
-        if (t.useUnlink !== void 0) {
-            this._useUnlink = t.useUnlink;
+        super.emit(e, ...t);
+    }
+    async serializeData(e) {
+        if (!this._serialize) {
+            return e;
         }
-        if (t.noNamespaceAffectsAll !== void 0) {
-            this._noNamespaceAffectsAll = t.noNamespaceAffectsAll;
+        if (this._compression?.compress) {
+            return this._serialize({
+                value: await this._compression.compress(e.value),
+                expires: e.expires
+            });
         }
-        if (t.throwOnConnectError !== void 0) {
-            this._throwOnConnectError = t.throwOnConnectError;
+        return this._serialize(e);
+    }
+    async deserializeData(e) {
+        if (!this._deserialize) {
+            return e;
         }
-        if (t.throwErrors !== void 0) {
-            this._throwErrors = t.throwErrors;
+        if (this._compression?.decompress && typeof e === "string") {
+            const t = await this._deserialize(e);
+            return {
+                value: await this._compression.decompress(t?.value),
+                expires: t?.expires
+            };
         }
-        if (t.connectionTimeout !== void 0) {
-            this._connectionTimeout = t.connectionTimeout;
+        if (typeof e === "string") {
+            return this._deserialize(e);
         }
-    }
-    initClient() {
-        this._client.on("connect", (() => {
-            this.emit("connect", this._client);
-        }));
-        this._client.on("disconnect", (() => {
-            this.emit("disconnect", this._client);
-        }));
-        this._client.on("reconnecting", (t => {
-            this.emit("reconnecting", t);
-        }));
-    }
-    async createTimeoutPromise(t) {
-        return new Promise(((e, s) => setTimeout((() => {
-            s(new Error(`Redis timed out after ${t}ms`));
-        }), t)));
+        return void 0;
     }
 };
 
-function h(t, e) {
-    t ??= "redis://localhost:6379";
-    const r = new c(t, e);
-    const i = new s(r, {
-        namespace: e?.namespace,
-        useKeyPrefix: false
-    });
-    return i;
-}
+var p = f;
 
-export { s as Keyv, o as RedisErrorMessages, h as createKeyv, c as default, a as defaultReconnectStrategy };
+export { f as K, s as d, p as i };