lakutata 2.0.80 → 2.0.81

package/vendor/Package.68.cjs

@@ -4,207 +4,116 @@ Object.defineProperty(exports, Symbol.toStringTag, {
     value: "Module"
 });
 
-const e = require("@redis/client");
+const t = require("@redis/client");
 
-const t = require("./Package.67.cjs");
+const e = require("cluster-key-slot");
 
-const r = require("cluster-key-slot");
+const r = require("./Package.66.cjs");
+
+const s = require("./Package.67.cjs");
 
 require("buffer");
 
-const s = e => e && e.__esModule ? e : {
-    default: e
+const i = t => t && t.__esModule ? t : {
+    default: t
 };
 
-const i = s(r);
+const n = i(e);
 
-var n = class {
-    _eventListeners;
-    _maxListeners;
-    _logger;
-    constructor(e) {
-        this._eventListeners = new Map, this._maxListeners = 100, this._logger = e?.logger;
-    }
-    once(e, t) {
-        let r = (...s) => {
-            this.off(e, r), t(...s);
-        };
-        return this.on(e, r), this;
-    }
-    listenerCount(e) {
-        if (!e) return this.getAllListeners().length;
-        let t = this._eventListeners.get(e);
-        return t ? t.length : 0;
-    }
-    eventNames() {
-        return [ ...this._eventListeners.keys() ];
-    }
-    rawListeners(e) {
-        return e ? this._eventListeners.get(e) ?? [] : this.getAllListeners();
-    }
-    prependListener(e, t) {
-        let r = this._eventListeners.get(e) ?? [];
-        return r.unshift(t), this._eventListeners.set(e, r), this;
-    }
-    prependOnceListener(e, t) {
-        let r = (...s) => {
-            this.off(e, r), t(...s);
-        };
-        return this.prependListener(e, r), this;
-    }
-    maxListeners() {
-        return this._maxListeners;
-    }
-    addListener(e, t) {
-        return this.on(e, t), this;
-    }
-    on(e, t) {
-        this._eventListeners.has(e) || this._eventListeners.set(e, []);
-        let r = this._eventListeners.get(e);
-        return r && (r.length >= this._maxListeners && console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${r.length + 1} ${e} listeners added. Use setMaxListeners() to increase limit.`), 
-        r.push(t)), this;
-    }
-    removeListener(e, t) {
-        return this.off(e, t), this;
-    }
-    off(e, t) {
-        let r = this._eventListeners.get(e) ?? [], s = r.indexOf(t);
-        return s !== -1 && r.splice(s, 1), r.length === 0 && this._eventListeners.delete(e), 
-        this;
-    }
-    emit(e, ...t) {
-        let r = !1, s = this._eventListeners.get(e);
-        if (s && s.length > 0) for (let e of s) e(...t), r = !0;
-        return r;
-    }
-    listeners(e) {
-        return this._eventListeners.get(e) ?? [];
-    }
-    removeAllListeners(e) {
-        return e ? this._eventListeners.delete(e) : this._eventListeners.clear(), this;
-    }
-    setMaxListeners(e) {
-        this._maxListeners = e;
-        for (let t of this._eventListeners.values()) t.length > e && t.splice(e);
-    }
-    getAllListeners() {
-        let e = new Array;
-        for (let t of this._eventListeners.values()) e = [ ...e, ...t ];
-        return e;
-    }
+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 c = t => {
+    const e = Math.min(2 ** t * 100, 2e3);
+    const r = (Math.random() - .5) * 100;
+    return e + r;
 };
 
-var o = class extends n {
-    _hooks;
-    _throwHookErrors=!1;
-    constructor(e) {
-        super({
-            logger: e?.logger
-        }), this._hooks = new Map, e?.throwHookErrors !== void 0 && (this._throwHookErrors = e.throwHookErrors);
-    }
-    get hooks() {
-        return this._hooks;
-    }
-    get throwHookErrors() {
-        return this._throwHookErrors;
-    }
-    set throwHookErrors(e) {
-        this._throwHookErrors = e;
-    }
-    get logger() {
-        return this._logger;
-    }
-    set logger(e) {
-        this._logger = e;
-    }
-    onHook(e, t) {
-        let r = this._hooks.get(e);
-        r ? r.push(t) : this._hooks.set(e, [ t ]);
-    }
-    addHook(e, t) {
-        this.onHook(e, t);
-    }
-    onHooks(e) {
-        for (let t of e) this.onHook(t.event, t.handler);
-    }
-    prependHook(e, t) {
-        let r = this._hooks.get(e);
-        r ? r.unshift(t) : this._hooks.set(e, [ t ]);
-    }
-    prependOnceHook(e, t) {
-        let r = async (...s) => (this.removeHook(e, r), t(...s));
-        this.prependHook(e, r);
-    }
-    onceHook(e, t) {
-        let r = async (...s) => (this.removeHook(e, r), t(...s));
-        this.onHook(e, r);
-    }
-    removeHook(e, t) {
-        let r = this._hooks.get(e);
-        if (r) {
-            let e = r.indexOf(t);
-            e !== -1 && r.splice(e, 1);
-        }
-    }
-    removeHooks(e) {
-        for (let t of e) this.removeHook(t.event, t.handler);
-    }
-    async hook(e, ...t) {
-        let r = this._hooks.get(e);
-        if (r) for (let s of r) try {
-            await s(...t);
-        } catch (t) {
-            let r = `${e}: ${t.message}`;
-            if (this.emit("error", new Error(r)), this._logger && this._logger.error(r), this._throwHookErrors) throw new Error(r);
+function a(t, e) {
+    t ??= "redis://localhost:6379";
+    const r = new l(t, e);
+    if (e?.namespace) {
+        r.namespace = e.namespace;
+        const t = new s.Keyv(r, {
+            namespace: e?.namespace,
+            useKeyPrefix: false
+        });
+        if (e?.throwOnConnectError) {
+            t.throwOnErrors = true;
+        }
+        if (e?.throwOnErrors) {
+            t.throwOnErrors = true;
         }
+        return t;
     }
-    async callHook(e, ...t) {
-        await this.hook(e, ...t);
-    }
-    getHooks(e) {
-        return this._hooks.get(e);
+    const i = new s.Keyv(r, {
+        useKeyPrefix: false
+    });
+    if (e?.throwOnConnectError) {
+        i.throwOnErrors = true;
     }
-    clearHooks() {
-        this._hooks.clear();
+    if (e?.throwOnErrors) {
+        i.throwOnErrors = true;
     }
-};
-
-var a = (e => {
-    e["RedisClientNotConnectedThrown"] = "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.";
-    return e;
-})(a || {});
+    i.namespace = void 0;
+    return i;
+}
 
-var c = e => {
-    const t = Math.min(2 ** e * 100, 2e3);
-    const r = (Math.random() - .5) * 100;
-    return t + r;
-};
+function h(t, e) {
+    const r = a(t, e);
+    const s = r.store;
+    s.throwOnConnectError = false;
+    s.throwOnErrors = false;
+    const i = s.client;
+    if (i.options) {
+        i.options.disableOfflineQueue = true;
+        if (i.options.socket) {
+            i.options.socket.reconnectStrategy = false;
+        }
+    }
+    r.throwOnErrors = false;
+    return r;
+}
 
-var h = class extends o {
-    _client=e.createClient();
+var l = class extends r.Hookified {
+    _client=t.createClient();
     _namespace;
     _keyPrefixSeparator="::";
     _clearBatchSize=1e3;
     _useUnlink=true;
     _noNamespaceAffectsAll=false;
     _throwOnConnectError=true;
-    _throwErrors=false;
+    _throwOnErrors=false;
     _connectionTimeout;
-    constructor(t, r) {
+    constructor(e, r) {
         super();
         const s = {
             reconnectStrategy: c
         };
-        if (t) {
-            if (typeof t === "string") {
-                this._client = e.createClient({
-                    url: t,
+        if (e) {
+            if (typeof e === "string") {
+                this._client = t.createClient({
+                    url: e,
                     socket: s
                 });
-            } else if (t.connect !== void 0) {
-                this._client = this.isClientCluster(t) ? t : t;
-            } else if (t instanceof Object) {
-                this._client = t.rootNodes === void 0 ? e.createClient(t) : e.createCluster(t);
+            } else if (e.connect !== void 0) {
+                if (this.isClientSentinel(e)) {
+                    this._client = e;
+                } else if (this.isClientCluster(e)) {
+                    this._client = e;
+                } else {
+                    this._client = e;
+                }
+            } else if (e instanceof Object) {
+                if (e.sentinelRootNodes !== void 0) {
+                    this._client = t.createSentinel(e);
+                } else if (e.rootNodes === void 0) {
+                    this._client = t.createClient(e);
+                } else {
+                    this._client = t.createCluster(e);
+                }
             }
         }
         this.setOptions(r);
@@ -213,53 +122,53 @@ var h = class extends o {
     get client() {
         return this._client;
     }
-    set client(e) {
-        this._client = e;
+    set client(t) {
+        this._client = t;
         this.initClient();
     }
     get opts() {
-        let e = "redis://localhost:6379";
+        let t = "redis://localhost:6379";
         if (this._client.options) {
-            const t = this._client.options?.url;
-            if (t) {
-                e = t;
+            const e = this._client.options?.url;
+            if (e) {
+                t = e;
             }
         }
-        const t = {
+        const e = {
             namespace: this._namespace,
             keyPrefixSeparator: this._keyPrefixSeparator,
             clearBatchSize: this._clearBatchSize,
             noNamespaceAffectsAll: this._noNamespaceAffectsAll,
             useUnlink: this._useUnlink,
             throwOnConnectError: this._throwOnConnectError,
-            throwErrors: this._throwErrors,
+            throwOnErrors: this._throwOnErrors,
             connectionTimeout: this._connectionTimeout,
             dialect: "redis",
-            url: e
+            url: t
         };
-        return t;
+        return e;
     }
-    set opts(e) {
-        this.setOptions(e);
+    set opts(t) {
+        this.setOptions(t);
     }
     get namespace() {
         return this._namespace;
     }
-    set namespace(e) {
-        this._namespace = e;
+    set namespace(t) {
+        this._namespace = t;
     }
     get keyPrefixSeparator() {
         return this._keyPrefixSeparator;
     }
-    set keyPrefixSeparator(e) {
-        this._keyPrefixSeparator = e;
+    set keyPrefixSeparator(t) {
+        this._keyPrefixSeparator = t;
     }
     get clearBatchSize() {
         return this._clearBatchSize;
     }
-    set clearBatchSize(e) {
-        if (e > 0) {
-            this._clearBatchSize = e;
+    set clearBatchSize(t) {
+        if (t > 0) {
+            this._clearBatchSize = t;
         } else {
             this.emit("error", "clearBatchSize must be greater than 0");
         }
@@ -267,32 +176,32 @@ var h = class extends o {
     get useUnlink() {
         return this._useUnlink;
     }
-    set useUnlink(e) {
-        this._useUnlink = e;
+    set useUnlink(t) {
+        this._useUnlink = t;
     }
     get noNamespaceAffectsAll() {
         return this._noNamespaceAffectsAll;
     }
-    set noNamespaceAffectsAll(e) {
-        this._noNamespaceAffectsAll = e;
+    set noNamespaceAffectsAll(t) {
+        this._noNamespaceAffectsAll = t;
     }
     get throwOnConnectError() {
         return this._throwOnConnectError;
     }
-    set throwOnConnectError(e) {
-        this._throwOnConnectError = e;
+    set throwOnConnectError(t) {
+        this._throwOnConnectError = t;
     }
-    get throwErrors() {
-        return this._throwErrors;
+    get throwOnErrors() {
+        return this._throwOnErrors;
     }
-    set throwErrors(e) {
-        this._throwErrors = e;
+    set throwOnErrors(t) {
+        this._throwOnErrors = t;
     }
     get connectionTimeout() {
         return this._connectionTimeout;
     }
-    set connectionTimeout(e) {
-        this._connectionTimeout = e;
+    set connectionTimeout(t) {
+        this._connectionTimeout = t;
     }
     async getClient() {
         if (this._client.isOpen) {
@@ -304,214 +213,292 @@ var h = class extends o {
             } else {
                 await Promise.race([ this._client.connect(), this.createTimeoutPromise(this._connectionTimeout) ]);
             }
-        } catch (e) {
-            this.emit("error", e);
+        } catch (t) {
+            this.emit("error", t);
+            await this.disconnect(true);
             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);
         }
         this.initClient();
         return this._client;
     }
-    async set(e, t, r) {
+    async set(t, e, r) {
         const s = await this.getClient();
         try {
-            e = this.createKeyPrefix(e, this._namespace);
+            t = this.createKeyPrefix(t, this._namespace);
             if (r) {
-                await s.set(e, t, {
+                await s.set(t, e, {
                     PX: r
                 });
             } else {
-                await s.set(e, t);
+                await s.set(t, e);
             }
-        } catch (e) {
-            this.emit("error", e);
-            if (this._throwErrors) {
-                throw e;
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
             }
         }
     }
-    async setMany(e) {
-        const t = await this.getClient();
+    async setMany(t) {
         try {
-            const r = t.multi();
-            for (const {key: t, value: s, ttl: i} of e) {
-                const e = this.createKeyPrefix(t, this._namespace);
-                if (i) {
-                    r.set(e, s, {
-                        PX: i
-                    });
-                } else {
-                    r.set(e, s);
+            if (this.isCluster()) {
+                await this.getClient();
+                const e = new Map;
+                for (const r of t) {
+                    const t = this.createKeyPrefix(r.key, this._namespace);
+                    const s = n.default(t);
+                    const i = e.get(s) ?? [];
+                    i.push(r);
+                    e.set(s, i);
+                }
+                await Promise.all(Array.from(e.entries(), (async ([t, e]) => {
+                    const r = await this.getSlotMaster(t);
+                    const s = r.multi();
+                    for (const {key: t, value: r, ttl: i} of e) {
+                        const e = this.createKeyPrefix(t, this._namespace);
+                        if (i) {
+                            s.set(e, r, {
+                                PX: i
+                            });
+                        } else {
+                            s.set(e, r);
+                        }
+                    }
+                    await s.exec();
+                })));
+            } else {
+                const e = await this.getClient();
+                const r = e.multi();
+                for (const {key: e, value: s, ttl: i} of t) {
+                    const t = this.createKeyPrefix(e, this._namespace);
+                    if (i) {
+                        r.set(t, s, {
+                            PX: i
+                        });
+                    } else {
+                        r.set(t, s);
+                    }
                 }
+                await r.exec();
             }
-            await r.exec();
-        } catch (e) {
-            this.emit("error", e);
-            if (this._throwErrors) {
-                throw e;
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnConnectError && t.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.") {
+                throw t;
+            }
+            if (this._throwOnErrors) {
+                throw t;
             }
         }
     }
-    async has(e) {
-        const t = await this.getClient();
+    async has(t) {
+        const e = await this.getClient();
         try {
-            e = this.createKeyPrefix(e, this._namespace);
-            const r = await t.exists(e);
+            t = this.createKeyPrefix(t, this._namespace);
+            const r = await e.exists(t);
             return r === 1;
-        } catch (e) {
-            this.emit("error", e);
-            if (this._throwErrors) {
-                throw e;
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
             }
             return false;
         }
     }
-    async hasMany(e) {
-        const t = await this.getClient();
+    async hasMany(t) {
         try {
-            const r = t.multi();
-            for (const t of e) {
-                const e = this.createKeyPrefix(t, this._namespace);
-                r.exists(e);
+            const e = t.map((t => this.createKeyPrefix(t, this._namespace)));
+            if (this.isCluster()) {
+                const t = this.getSlotMap(e);
+                const r = new Map;
+                await Promise.all(Array.from(t.entries(), (async ([t, e]) => {
+                    const s = await this.getSlotMaster(t);
+                    const i = s.multi();
+                    for (const t of e) {
+                        i.exists(t);
+                    }
+                    const n = await i.exec();
+                    for (const [t, s] of n.entries()) {
+                        r.set(e[t], typeof s === "number" && s === 1);
+                    }
+                })));
+                return e.map((t => r.get(t) ?? false));
+            } else {
+                const t = await this.getClient();
+                const r = t.multi();
+                for (const t of e) {
+                    r.exists(t);
+                }
+                const s = await r.exec();
+                return s.map((t => typeof t === "number" && t === 1));
             }
-            const s = await r.exec();
-            return s.map((e => e === 1));
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
+        } catch (e) {
+            this.emit("error", e);
+            if (this._throwOnConnectError && e.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.") {
+                throw e;
+            }
+            if (this._throwOnErrors) {
+                throw e;
             }
             return Array.from({
-                length: e.length
+                length: t.length
             }).fill(false);
         }
     }
-    async get(e) {
-        const t = await this.getClient();
+    async get(t) {
+        const e = await this.getClient();
         try {
-            e = this.createKeyPrefix(e, this._namespace);
-            const r = await t.get(e);
+            t = this.createKeyPrefix(t, this._namespace);
+            const r = await e.get(t);
             if (r === null) {
                 return void 0;
             }
             return r;
-        } catch (e) {
-            this.emit("error", e);
-            if (this._throwErrors) {
-                throw e;
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
             }
             return void 0;
         }
     }
-    async getMany(e) {
-        if (e.length === 0) {
+    async getMany(t) {
+        if (t.length === 0) {
             return [];
         }
-        e = e.map((e => this.createKeyPrefix(e, this._namespace)));
+        t = t.map((t => this.createKeyPrefix(t, this._namespace)));
         try {
-            const t = await this.mget(e);
-            return t;
-        } catch (t) {
-            this.emit("error", t);
-            if (this._throwErrors) {
-                throw t;
+            const e = await this.mget(t);
+            return e;
+        } catch (e) {
+            this.emit("error", e);
+            if (this._throwOnErrors) {
+                throw e;
             }
             return Array.from({
-                length: e.length
+                length: t.length
             }).fill(void 0);
         }
     }
-    async delete(e) {
-        const t = await this.getClient();
+    async delete(t) {
+        const e = await this.getClient();
         try {
-            e = this.createKeyPrefix(e, this._namespace);
+            t = this.createKeyPrefix(t, this._namespace);
             let r = 0;
-            r = await (this._useUnlink ? t.unlink(e) : t.del(e));
+            r = await (this._useUnlink ? e.unlink(t) : e.del(t));
             return r > 0;
-        } catch (e) {
-            this.emit("error", e);
-            if (this._throwErrors) {
-                throw e;
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnErrors) {
+                throw t;
             }
             return false;
         }
     }
-    async deleteMany(e) {
-        let t = false;
-        const r = await this.getClient();
+    async deleteMany(t) {
+        let e = false;
         try {
-            const s = r.multi();
-            for (const t of e) {
-                const e = this.createKeyPrefix(t, this._namespace);
-                if (this._useUnlink) {
-                    s.unlink(e);
-                } else {
-                    s.del(e);
+            const r = t.map((t => this.createKeyPrefix(t, this._namespace)));
+            if (this.isCluster()) {
+                const t = this.getSlotMap(r);
+                await Promise.all(Array.from(t.entries(), (async ([t, r]) => {
+                    const s = await this.getSlotMaster(t);
+                    const i = s.multi();
+                    for (const t of r) {
+                        if (this._useUnlink) {
+                            i.unlink(t);
+                        } else {
+                            i.del(t);
+                        }
+                    }
+                    const n = await i.exec();
+                    for (const t of n) {
+                        if (typeof t === "number" && t > 0) {
+                            e = true;
+                        }
+                    }
+                })));
+            } else {
+                const t = await this.getClient();
+                const s = t.multi();
+                for (const t of r) {
+                    if (this._useUnlink) {
+                        s.unlink(t);
+                    } else {
+                        s.del(t);
+                    }
                 }
-            }
-            const i = await s.exec();
-            for (const e of i) {
-                if (typeof e === "number" && e > 0) {
-                    t = true;
+                const i = await s.exec();
+                for (const t of i) {
+                    if (typeof t === "number" && t > 0) {
+                        e = true;
+                    }
                 }
             }
-        } catch (e) {
-            this.emit("error", e);
-            if (this._throwErrors) {
-                throw e;
+        } catch (t) {
+            this.emit("error", t);
+            if (this._throwOnConnectError && t.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.") {
+                throw t;
+            }
+            if (this._throwOnErrors) {
+                throw t;
             }
         }
-        return t;
+        return e;
     }
-    async disconnect(e) {
+    async disconnect(t) {
         if (this._client.isOpen) {
-            await (e ? this._client.disconnect() : this._client.quit());
+            await (t ? this._client.destroy() : this._client.close());
         }
     }
-    createKeyPrefix(e, t) {
-        if (t) {
-            return `${t}${this._keyPrefixSeparator}${e}`;
+    createKeyPrefix(t, e) {
+        if (e) {
+            return `${e}${this._keyPrefixSeparator}${t}`;
         }
-        return e;
+        return t;
     }
-    getKeyWithoutPrefix(e, t) {
-        if (t) {
-            return e.replace(`${t}${this._keyPrefixSeparator}`, "");
+    getKeyWithoutPrefix(t, e) {
+        if (e) {
+            return t.replace(`${e}${this._keyPrefixSeparator}`, "");
         }
-        return e;
+        return t;
     }
     isCluster() {
         return this.isClientCluster(this._client);
     }
+    isSentinel() {
+        return this.isClientSentinel(this._client);
+    }
     async getMasterNodes() {
         if (this.isCluster()) {
-            const e = await this.getClient();
-            return Promise.all(e.masters.map((async t => e.nodeClient(t))));
+            const t = await this.getClient();
+            const e = t.masters.map((async e => t.nodeClient(e)));
+            return Promise.all(e);
         }
         return [ await this.getClient() ];
     }
-    async* iterator(e) {
-        const t = await this.getMasterNodes();
-        for (const r of t) {
-            const t = e ? `${e}${this._keyPrefixSeparator}*` : "*";
+    async* iterator(t) {
+        const e = await this.getMasterNodes();
+        for (const r of e) {
+            const e = t ? `${t}${this._keyPrefixSeparator}*` : "*";
             let s = "0";
             do {
-                const i = await r.scan(Number.parseInt(s, 10), {
-                    MATCH: t,
+                const i = await r.scan(s, {
+                    MATCH: e,
                     TYPE: "string"
                 });
                 s = i.cursor.toString();
                 let {keys: n} = i;
-                if (!e && !this._noNamespaceAffectsAll) {
-                    n = n.filter((e => !e.includes(this._keyPrefixSeparator)));
+                if (!t && !this._noNamespaceAffectsAll) {
+                    n = n.filter((t => !t.includes(this._keyPrefixSeparator)));
                 }
                 if (n.length > 0) {
-                    const t = await this.mget(n);
+                    const e = await this.mget(n);
                     for (const r of n.keys()) {
-                        const s = this.getKeyWithoutPrefix(n[r], e);
-                        const i = t[r];
+                        const s = this.getKeyWithoutPrefix(n[r], t);
+                        const i = e[r];
                         yield [ s, i ];
                     }
                 }
@@ -520,115 +507,123 @@ var h = class extends o {
     }
     async clear() {
         try {
-            const e = await this.getMasterNodes();
-            await Promise.all(e.map((async e => {
+            const t = await this.getMasterNodes();
+            await Promise.all(t.map((async t => {
                 if (!this._namespace && this._noNamespaceAffectsAll) {
-                    await e.flushDb();
+                    await t.flushDb();
                     return;
                 }
-                let t = "0";
+                let e = "0";
                 const r = this._clearBatchSize;
                 const s = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
                 const i = [];
                 do {
-                    const n = await e.scan(Number.parseInt(t, 10), {
+                    const n = await t.scan(e, {
                         MATCH: s,
                         COUNT: r,
                         TYPE: "string"
                     });
-                    t = n.cursor.toString();
+                    e = n.cursor.toString();
                     let {keys: o} = n;
                     if (o.length === 0) {
                         continue;
                     }
                     if (!this._namespace) {
-                        o = o.filter((e => !e.includes(this._keyPrefixSeparator)));
+                        o = o.filter((t => !t.includes(this._keyPrefixSeparator)));
                     }
                     i.push(this.clearWithClusterSupport(o));
-                } while (t !== "0");
+                } while (e !== "0");
                 await Promise.all(i);
             })));
-        } catch (e) {
-            this.emit("error", e);
+        } catch (t) {
+            this.emit("error", t);
         }
     }
-    async mget(e) {
-        const t = this.getSlotMap(e);
-        const r = new Map;
-        await Promise.all(Array.from(t.entries(), (async ([e, t]) => {
-            const s = await this.getSlotMaster(e);
-            const i = await s.mGet(t);
-            for (const [e, s] of i.entries()) {
-                r.set(t[e], s ?? void 0);
+    async mget(t) {
+        const e = new Map;
+        if (this.isCluster()) {
+            const r = this.getSlotMap(t);
+            await Promise.all(Array.from(r.entries(), (async ([t, r]) => {
+                const s = await this.getSlotMaster(t);
+                const i = await s.mGet(r);
+                for (const [t, s] of i.entries()) {
+                    e.set(r[t], s ?? void 0);
+                }
+            })));
+        } else {
+            const r = await this.getClient();
+            const s = await r.mGet(t);
+            for (const [r, i] of s.entries()) {
+                e.set(t[r], i ?? void 0);
             }
-        })));
-        return e.map((e => r.get(e)));
-    }
-    async clearWithClusterSupport(e) {
-        if (e.length > 0) {
-            const t = this.getSlotMap(e);
-            await Promise.all(Array.from(t.entries(), (async ([e, t]) => {
-                const r = await this.getSlotMaster(e);
-                return this._useUnlink ? r.unlink(t) : r.del(t);
+        }
+        return t.map((t => e.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 r = await this.getSlotMaster(t);
+                return this._useUnlink ? r.unlink(e) : r.del(e);
             })));
         }
     }
-    async getSlotMaster(e) {
-        const t = await this.getClient();
+    async getSlotMaster(t) {
+        const e = await this.getClient();
         if (this.isCluster()) {
-            const r = t;
-            const s = r.slots[e].master;
+            const r = e;
+            const s = r.slots[t].master;
             return r.nodeClient(s);
         }
-        return t;
+        return e;
     }
-    getSlotMap(e) {
-        const t = new Map;
+    getSlotMap(t) {
+        const e = new Map;
         if (this.isCluster()) {
-            for (const r of e) {
-                const e = i.default(r);
-                const s = t.get(e) ?? [];
+            for (const r of t) {
+                const t = n.default(r);
+                const s = e.get(t) ?? [];
                 s.push(r);
-                t.set(e, s);
+                e.set(t, s);
             }
         } else {
-            t.set(0, e);
+            e.set(0, t);
         }
-        return t;
+        return e;
     }
-    isClientCluster(e) {
-        if (e.options === void 0 && e.scan === void 0) {
-            return true;
-        }
-        return false;
+    isClientCluster(t) {
+        return t.slots !== void 0;
     }
-    setOptions(e) {
-        if (!e) {
+    isClientSentinel(t) {
+        return t.getSentinelNode !== void 0;
+    }
+    setOptions(t) {
+        if (!t) {
             return;
         }
-        if (e.namespace) {
-            this._namespace = e.namespace;
+        if (t.namespace) {
+            this._namespace = t.namespace;
         }
-        if (e.keyPrefixSeparator !== void 0) {
-            this._keyPrefixSeparator = e.keyPrefixSeparator;
+        if (t.keyPrefixSeparator !== void 0) {
+            this._keyPrefixSeparator = t.keyPrefixSeparator;
         }
-        if (e.clearBatchSize !== void 0 && e.clearBatchSize > 0) {
-            this._clearBatchSize = e.clearBatchSize;
+        if (t.clearBatchSize !== void 0 && t.clearBatchSize > 0) {
+            this._clearBatchSize = t.clearBatchSize;
         }
-        if (e.useUnlink !== void 0) {
-            this._useUnlink = e.useUnlink;
+        if (t.useUnlink !== void 0) {
+            this._useUnlink = t.useUnlink;
         }
-        if (e.noNamespaceAffectsAll !== void 0) {
-            this._noNamespaceAffectsAll = e.noNamespaceAffectsAll;
+        if (t.noNamespaceAffectsAll !== void 0) {
+            this._noNamespaceAffectsAll = t.noNamespaceAffectsAll;
         }
-        if (e.throwOnConnectError !== void 0) {
-            this._throwOnConnectError = e.throwOnConnectError;
+        if (t.throwOnConnectError !== void 0) {
+            this._throwOnConnectError = t.throwOnConnectError;
         }
-        if (e.throwErrors !== void 0) {
-            this._throwErrors = e.throwErrors;
+        if (t.throwOnErrors !== void 0) {
+            this._throwOnErrors = t.throwOnErrors;
         }
-        if (e.connectionTimeout !== void 0) {
-            this._connectionTimeout = e.connectionTimeout;
+        if (t.connectionTimeout !== void 0) {
+            this._connectionTimeout = t.connectionTimeout;
         }
     }
     initClient() {
@@ -638,43 +633,40 @@ var h = class extends o {
         this._client.on("disconnect", (() => {
             this.emit("disconnect", this._client);
         }));
-        this._client.on("reconnecting", (e => {
-            this.emit("reconnecting", e);
+        this._client.on("reconnecting", (t => {
+            this.emit("reconnecting", t);
         }));
     }
-    async createTimeoutPromise(e) {
-        return new Promise(((t, r) => setTimeout((() => {
-            r(new Error(`Redis timed out after ${e}ms`));
-        }), e)));
+    async createTimeoutPromise(t) {
+        return new Promise(((e, r) => setTimeout((() => {
+            r(new Error(`Redis timed out after ${t}ms`));
+        }), t)));
     }
 };
 
-function l(e, r) {
-    e ??= "redis://localhost:6379";
-    const s = new h(e, r);
-    const i = new t.Keyv(s, {
-        namespace: r?.namespace,
-        useKeyPrefix: false
-    });
-    return i;
-}
-
 Object.defineProperty(exports, "createClient", {
     enumerable: true,
-    get: () => e.createClient
+    get: () => t.createClient
 });
 
 Object.defineProperty(exports, "createCluster", {
     enumerable: true,
-    get: () => e.createCluster
+    get: () => t.createCluster
 });
 
-exports.Keyv = t.Keyv;
+Object.defineProperty(exports, "createSentinel", {
+    enumerable: true,
+    get: () => t.createSentinel
+});
+
+exports.Keyv = s.Keyv;
+
+exports.RedisErrorMessages = o;
 
-exports.RedisErrorMessages = a;
+exports.createKeyv = a;
 
-exports.createKeyv = l;
+exports.createKeyvNonBlocking = h;
 
-exports.default = h;
+exports.default = l;
 
 exports.defaultReconnectStrategy = c;